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

[Fan WenJie (＠fanwenjie)]

function call from windows dll to unix function should use `__wine_unix_call` instead of callback function pointer. remove callback struct unix_funcs and add wrapper function of `unixlib_entry_t` type.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/655

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

[fanwenjie]

From: fanwenjie <fanwj(a)mail.ustc.edu.cn>

---
 dlls/win32u/gdiobj.c         |  132 ----
 dlls/win32u/syscall.c        |  859 ++++++++++++++++++++++-
 dlls/win32u/win32u_private.h | 1286 +++++++++++++++++++++++++++++-----
 dlls/win32u/wrappers.c       |  807 ++++++++++-----------
 4 files changed, 2342 insertions(+), 742 deletions(-)

diff --git a/dlls/win32u/gdiobj.c b/dlls/win32u/gdiobj.c
index 881c76ee165..6194672029e 100644
--- a/dlls/win32u/gdiobj.c
+++ b/dlls/win32u/gdiobj.c
@@ -1027,132 +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_get_wgl_driver,
-    __wine_send_input,
-};
-
 NTSTATUS gdi_init(void)
 {
     pthread_mutexattr_t attr;
@@ -1171,9 +1045,3 @@ NTSTATUS gdi_init(void)
     init_stock_objects( dpi );
     return 0;
 }
-
-NTSTATUS callbacks_init( void *args )
-{
-    *(const struct unix_funcs **)args = &unix_funcs;
-    return 0;
-}
diff --git a/dlls/win32u/syscall.c b/dlls/win32u/syscall.c
index e36e7097047..03386fd58a7 100644
--- a/dlls/win32u/syscall.c
+++ b/dlls/win32u/syscall.c
@@ -323,10 +323,863 @@ static NTSTATUS init( void *dispatcher )
     return STATUS_SUCCESS;
 }
 
-unixlib_entry_t __wine_unix_call_funcs[] =
+static NTSTATUS win32u_NtGdiAbortDoc(void* args)
 {
-    init,
-    callbacks_init,
+    struct NtGdiAbortDoc_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiAbortDoc(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiAbortPath(void* args)
+{
+    struct NtGdiAbortPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiAbortPath(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiAlphaBlend(void* args)
+{
+    struct NtGdiAlphaBlend_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiAlphaBlend(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10, params->arg11);
+}
+
+static NTSTATUS win32u_NtGdiAngleArc(void* args)
+{
+    struct NtGdiAngleArc_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiAngleArc(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiArcInternal(void* args)
+{
+    struct NtGdiArcInternal_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiArcInternal(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9);
+}
+
+static NTSTATUS win32u_NtGdiBeginPath(void* args)
+{
+    struct NtGdiBeginPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiBeginPath(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiBitBlt(void* args)
+{
+    struct NtGdiBitBlt_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiBitBlt(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10);
+}
+
+static NTSTATUS win32u_NtGdiCloseFigure(void* args)
+{
+    struct NtGdiCloseFigure_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiCloseFigure(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiComputeXformCoefficients(void* args)
+{
+    struct NtGdiComputeXformCoefficients_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiComputeXformCoefficients(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiCreateCompatibleBitmap(void* args)
+{
+    struct NtGdiCreateCompatibleBitmap_params *params = (typeof(params))args; 
+    params->result = NtGdiCreateCompatibleBitmap(params->arg0, params->arg1, params->arg2);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateCompatibleDC(void* args)
+{
+    struct NtGdiCreateCompatibleDC_params *params = (typeof(params))args; 
+    params->result = NtGdiCreateCompatibleDC(params->arg0);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateDIBitmapInternal(void* args)
+{
+    struct NtGdiCreateDIBitmapInternal_params *params = (typeof(params))args; 
+    params->result = NtGdiCreateDIBitmapInternal(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateMetafileDC(void* args)
+{
+    struct NtGdiCreateMetafileDC_params *params = (typeof(params))args; 
+    params->result = NtGdiCreateMetafileDC(params->arg0);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDICheckVidPnExclusiveOwnership(void* args)
+{
+    struct NtGdiDdDDICheckVidPnExclusiveOwnership_params *params = (typeof(params))args; 
+    return NtGdiDdDDICheckVidPnExclusiveOwnership(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDICloseAdapter(void* args)
+{
+    struct NtGdiDdDDICloseAdapter_params *params = (typeof(params))args; 
+    return NtGdiDdDDICloseAdapter(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDICreateDCFromMemory(void* args)
+{
+    struct NtGdiDdDDICreateDCFromMemory_params *params = (typeof(params))args; 
+    return NtGdiDdDDICreateDCFromMemory(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDIDestroyDCFromMemory(void* args)
+{
+    struct NtGdiDdDDIDestroyDCFromMemory_params *params = (typeof(params))args; 
+    return NtGdiDdDDIDestroyDCFromMemory(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDIDestroyDevice(void* args)
+{
+    struct NtGdiDdDDIDestroyDevice_params *params = (typeof(params))args; 
+    return NtGdiDdDDIDestroyDevice(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDIEscape(void* args)
+{
+    struct NtGdiDdDDIEscape_params *params = (typeof(params))args; 
+    return NtGdiDdDDIEscape(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDIOpenAdapterFromDeviceName(void* args)
+{
+    struct NtGdiDdDDIOpenAdapterFromDeviceName_params *params = (typeof(params))args; 
+    return NtGdiDdDDIOpenAdapterFromDeviceName(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDIOpenAdapterFromLuid(void* args)
+{
+    struct NtGdiDdDDIOpenAdapterFromLuid_params *params = (typeof(params))args; 
+    return NtGdiDdDDIOpenAdapterFromLuid(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDIQueryVideoMemoryInfo(void* args)
+{
+    struct NtGdiDdDDIQueryVideoMemoryInfo_params *params = (typeof(params))args; 
+    return NtGdiDdDDIQueryVideoMemoryInfo(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDdDDISetVidPnSourceOwner(void* args)
+{
+    struct NtGdiDdDDISetVidPnSourceOwner_params *params = (typeof(params))args; 
+    return NtGdiDdDDISetVidPnSourceOwner(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDeleteObjectApp(void* args)
+{
+    struct NtGdiDeleteObjectApp_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiDeleteObjectApp(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiDoPalette(void* args)
+{
+    struct NtGdiDoPalette_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiDoPalette(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiEllipse(void* args)
+{
+    struct NtGdiEllipse_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiEllipse(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiEndDoc(void* args)
+{
+    struct NtGdiEndDoc_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiEndDoc(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiEndPage(void* args)
+{
+    struct NtGdiEndPage_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiEndPage(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiEndPath(void* args)
+{
+    struct NtGdiEndPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiEndPath(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiEnumFonts(void* args)
+{
+    struct NtGdiEnumFonts_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiEnumFonts(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7);
+}
+
+static NTSTATUS win32u_NtGdiExcludeClipRect(void* args)
+{
+    struct NtGdiExcludeClipRect_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiExcludeClipRect(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiExtEscape(void* args)
+{
+    struct NtGdiExtEscape_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiExtEscape(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7);
+}
+
+static NTSTATUS win32u_NtGdiExtFloodFill(void* args)
+{
+    struct NtGdiExtFloodFill_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiExtFloodFill(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiExtSelectClipRgn(void* args)
+{
+    struct NtGdiExtSelectClipRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiExtSelectClipRgn(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiExtTextOutW(void* args)
+{
+    struct NtGdiExtTextOutW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiExtTextOutW(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8);
+}
+
+static NTSTATUS win32u_NtGdiFillPath(void* args)
+{
+    struct NtGdiFillPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiFillPath(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiFillRgn(void* args)
+{
+    struct NtGdiFillRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiFillRgn(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiFontIsLinked(void* args)
+{
+    struct NtGdiFontIsLinked_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiFontIsLinked(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiFrameRgn(void* args)
+{
+    struct NtGdiFrameRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiFrameRgn(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiGetAndSetDCDword(void* args)
+{
+    struct NtGdiGetAndSetDCDword_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetAndSetDCDword(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u_NtGdiGetAppClipBox(void* args)
+{
+    struct NtGdiGetAppClipBox_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetAppClipBox(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetBoundsRect(void* args)
+{
+    struct NtGdiGetBoundsRect_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetBoundsRect(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiGetCharABCWidthsW(void* args)
+{
+    struct NtGdiGetCharABCWidthsW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetCharABCWidthsW(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiGetCharWidthInfo(void* args)
+{
+    struct NtGdiGetCharWidthInfo_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetCharWidthInfo(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetCharWidthW(void* args)
+{
+    struct NtGdiGetCharWidthW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetCharWidthW(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiGetDIBitsInternal(void* args)
+{
+    struct NtGdiGetDIBitsInternal_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetDIBitsInternal(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8);
+}
+
+static NTSTATUS win32u_NtGdiGetDeviceCaps(void* args)
+{
+    struct NtGdiGetDeviceCaps_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetDeviceCaps(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetDeviceGammaRamp(void* args)
+{
+    struct NtGdiGetDeviceGammaRamp_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetDeviceGammaRamp(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetFontData(void* args)
+{
+    struct NtGdiGetFontData_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetFontData(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiGetFontUnicodeRanges(void* args)
+{
+    struct NtGdiGetFontUnicodeRanges_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetFontUnicodeRanges(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetGlyphIndicesW(void* args)
+{
+    struct NtGdiGetGlyphIndicesW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetGlyphIndicesW(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiGetGlyphOutline(void* args)
+{
+    struct NtGdiGetGlyphOutline_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetGlyphOutline(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7);
+}
+
+static NTSTATUS win32u_NtGdiGetKerningPairs(void* args)
+{
+    struct NtGdiGetKerningPairs_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetKerningPairs(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiGetNearestColor(void* args)
+{
+    struct NtGdiGetNearestColor_params *params = (typeof(params))args; 
+    params->result = NtGdiGetNearestColor(params->arg0, params->arg1);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetOutlineTextMetricsInternalW(void* args)
+{
+    struct NtGdiGetOutlineTextMetricsInternalW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetOutlineTextMetricsInternalW(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u_NtGdiGetPixel(void* args)
+{
+    struct NtGdiGetPixel_params *params = (typeof(params))args; 
+    params->result = NtGdiGetPixel(params->arg0, params->arg1, params->arg2);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetRandomRgn(void* args)
+{
+    struct NtGdiGetRandomRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetRandomRgn(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiGetRasterizerCaps(void* args)
+{
+    struct NtGdiGetRasterizerCaps_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetRasterizerCaps(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetRealizationInfo(void* args)
+{
+    struct NtGdiGetRealizationInfo_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetRealizationInfo(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiGetTextCharsetInfo(void* args)
+{
+    struct NtGdiGetTextCharsetInfo_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetTextCharsetInfo(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiGetTextExtentExW(void* args)
+{
+    struct NtGdiGetTextExtentExW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetTextExtentExW(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7);
+}
+
+static NTSTATUS win32u_NtGdiGetTextFaceW(void* args)
+{
+    struct NtGdiGetTextFaceW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetTextFaceW(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u_NtGdiGetTextMetricsW(void* args)
+{
+    struct NtGdiGetTextMetricsW_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGetTextMetricsW(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiGradientFill(void* args)
+{
+    struct NtGdiGradientFill_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiGradientFill(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiIntersectClipRect(void* args)
+{
+    struct NtGdiIntersectClipRect_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiIntersectClipRect(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiInvertRgn(void* args)
+{
+    struct NtGdiInvertRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiInvertRgn(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiLineTo(void* args)
+{
+    struct NtGdiLineTo_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiLineTo(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiMaskBlt(void* args)
+{
+    struct NtGdiMaskBlt_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiMaskBlt(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10, params->arg11, params->arg12);
+}
+
+static NTSTATUS win32u_NtGdiModifyWorldTransform(void* args)
+{
+    struct NtGdiModifyWorldTransform_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiModifyWorldTransform(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiMoveTo(void* args)
+{
+    struct NtGdiMoveTo_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiMoveTo(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u_NtGdiOffsetClipRgn(void* args)
+{
+    struct NtGdiOffsetClipRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiOffsetClipRgn(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiOpenDCW(void* args)
+{
+    struct NtGdiOpenDCW_params *params = (typeof(params))args; 
+    params->result = NtGdiOpenDCW(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiPatBlt(void* args)
+{
+    struct NtGdiPatBlt_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiPatBlt(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiPlgBlt(void* args)
+{
+    struct NtGdiPlgBlt_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiPlgBlt(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10);
+}
+
+static NTSTATUS win32u_NtGdiPolyDraw(void* args)
+{
+    struct NtGdiPolyDraw_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiPolyDraw(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u_NtGdiPolyPolyDraw(void* args)
+{
+    struct NtGdiPolyPolyDraw_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiPolyPolyDraw(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiPtVisible(void* args)
+{
+    struct NtGdiPtVisible_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiPtVisible(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiRectVisible(void* args)
+{
+    struct NtGdiRectVisible_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiRectVisible(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiRectangle(void* args)
+{
+    struct NtGdiRectangle_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiRectangle(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiResetDC(void* args)
+{
+    struct NtGdiResetDC_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiResetDC(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtGdiResizePalette(void* args)
+{
+    struct NtGdiResizePalette_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiResizePalette(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiRestoreDC(void* args)
+{
+    struct NtGdiRestoreDC_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiRestoreDC(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiRoundRect(void* args)
+{
+    struct NtGdiRoundRect_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiRoundRect(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6);
+}
+
+static NTSTATUS win32u_NtGdiScaleViewportExtEx(void* args)
+{
+    struct NtGdiScaleViewportExtEx_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiScaleViewportExtEx(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiScaleWindowExtEx(void* args)
+{
+    struct NtGdiScaleWindowExtEx_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiScaleWindowExtEx(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5);
+}
+
+static NTSTATUS win32u_NtGdiSelectBitmap(void* args)
+{
+    struct NtGdiSelectBitmap_params *params = (typeof(params))args; 
+    params->result = NtGdiSelectBitmap(params->arg0, params->arg1);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectBrush(void* args)
+{
+    struct NtGdiSelectBrush_params *params = (typeof(params))args; 
+    params->result = NtGdiSelectBrush(params->arg0, params->arg1);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectClipPath(void* args)
+{
+    struct NtGdiSelectClipPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiSelectClipPath(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiSelectFont(void* args)
+{
+    struct NtGdiSelectFont_params *params = (typeof(params))args; 
+    params->result = NtGdiSelectFont(params->arg0, params->arg1);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectPen(void* args)
+{
+    struct NtGdiSelectPen_params *params = (typeof(params))args; 
+    params->result = NtGdiSelectPen(params->arg0, params->arg1);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetBoundsRect(void* args)
+{
+    struct NtGdiSetBoundsRect_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiSetBoundsRect(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiSetDIBitsToDeviceInternal(void* args)
+{
+    struct NtGdiSetDIBitsToDeviceInternal_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiSetDIBitsToDeviceInternal(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10, params->arg11, params->arg12, params->arg13, params->arg14, params->arg15);
+}
+
+static NTSTATUS win32u_NtGdiSetDeviceGammaRamp(void* args)
+{
+    struct NtGdiSetDeviceGammaRamp_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiSetDeviceGammaRamp(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiSetLayout(void* args)
+{
+    struct NtGdiSetLayout_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiSetLayout(params->arg0, params->arg1, params->arg2);
+}
+
+static NTSTATUS win32u_NtGdiSetPixel(void* args)
+{
+    struct NtGdiSetPixel_params *params = (typeof(params))args; 
+    params->result = NtGdiSetPixel(params->arg0, params->arg1, params->arg2, params->arg3);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetSystemPaletteUse(void* args)
+{
+    struct NtGdiSetSystemPaletteUse_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiSetSystemPaletteUse(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtGdiStartDoc(void* args)
+{
+    struct NtGdiStartDoc_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiStartDoc(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u_NtGdiStartPage(void* args)
+{
+    struct NtGdiStartPage_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiStartPage(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiStretchBlt(void* args)
+{
+    struct NtGdiStretchBlt_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiStretchBlt(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10, params->arg11);
+}
+
+static NTSTATUS win32u_NtGdiStretchDIBitsInternal(void* args)
+{
+    struct NtGdiStretchDIBitsInternal_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiStretchDIBitsInternal(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10, params->arg11, params->arg12, params->arg13, params->arg14, params->arg15);
+}
+
+static NTSTATUS win32u_NtGdiStrokeAndFillPath(void* args)
+{
+    struct NtGdiStrokeAndFillPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiStrokeAndFillPath(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiStrokePath(void* args)
+{
+    struct NtGdiStrokePath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiStrokePath(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiTransparentBlt(void* args)
+{
+    struct NtGdiTransparentBlt_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiTransparentBlt(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9, params->arg10);
+}
+
+static NTSTATUS win32u_NtGdiUnrealizeObject(void* args)
+{
+    struct NtGdiUnrealizeObject_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiUnrealizeObject(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiUpdateColors(void* args)
+{
+    struct NtGdiUpdateColors_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiUpdateColors(params->arg0);
+}
+
+static NTSTATUS win32u_NtGdiWidenPath(void* args)
+{
+    struct NtGdiWidenPath_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtGdiWidenPath(params->arg0);
+}
+
+static NTSTATUS win32u_NtUserDrawCaptionTemp(void* args)
+{
+    struct NtUserDrawCaptionTemp_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserDrawCaptionTemp(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6);
+}
+
+static NTSTATUS win32u_NtUserDrawMenuBarTemp(void* args)
+{
+    struct NtUserDrawMenuBarTemp_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserDrawMenuBarTemp(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4);
+}
+
+static NTSTATUS win32u_NtUserEndPaint(void* args)
+{
+    struct NtUserEndPaint_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserEndPaint(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtUserExcludeUpdateRgn(void* args)
+{
+    struct NtUserExcludeUpdateRgn_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserExcludeUpdateRgn(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtUserReleaseDC(void* args)
+{
+    struct NtUserReleaseDC_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserReleaseDC(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u_NtUserScrollDC(void* args)
+{
+    struct NtUserScrollDC_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserScrollDC(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6);
+}
+
+static NTSTATUS win32u_NtUserSelectPalette(void* args)
+{
+    struct NtUserSelectPalette_params *params = (typeof(params))args; 
+    params->result = NtUserSelectPalette(params->arg0, params->arg1, params->arg2);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserUpdateLayeredWindow(void* args)
+{
+    struct NtUserUpdateLayeredWindow_params *params = (typeof(params))args; 
+    return (NTSTATUS)NtUserUpdateLayeredWindow(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6, params->arg7, params->arg8, params->arg9);
+}
+
+static NTSTATUS win32u_SetDIBits(void* args)
+{
+    struct SetDIBits_params *params = (typeof(params))args; 
+    return (NTSTATUS)SetDIBits(params->arg0, params->arg1, params->arg2, params->arg3, params->arg4, params->arg5, params->arg6);
+}
+
+static NTSTATUS win32u___wine_get_brush_bitmap_info(void* args)
+{
+    struct __wine_get_brush_bitmap_info_params *params = (typeof(params))args; 
+    return (NTSTATUS)__wine_get_brush_bitmap_info(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u___wine_get_file_outline_text_metric(void* args)
+{
+    struct __wine_get_file_outline_text_metric_params *params = (typeof(params))args; 
+    return (NTSTATUS)__wine_get_file_outline_text_metric(params->arg0, params->arg1);
+}
+
+static NTSTATUS win32u___wine_get_icm_profile(void* args)
+{
+    struct __wine_get_icm_profile_params *params = (typeof(params))args; 
+    return (NTSTATUS)__wine_get_icm_profile(params->arg0, params->arg1, params->arg2, params->arg3);
+}
+
+static NTSTATUS win32u___wine_get_wgl_driver(void* args)
+{
+    struct __wine_get_wgl_driver_params *params = (typeof(params))args; 
+    params->result = __wine_get_wgl_driver(params->arg0, params->arg1);
+    return 0;
+}
+
+static NTSTATUS win32u___wine_send_input(void* args)
+{
+    struct __wine_send_input_params *params = (typeof(params))args; 
+    return (NTSTATUS)__wine_send_input(params->arg0, params->arg1, params->arg2);
+}
+
+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_get_wgl_driver,
+    &win32u___wine_send_input,
 };
 
 #ifdef _WIN64
diff --git a/dlls/win32u/win32u_private.h b/dlls/win32u/win32u_private.h
index dcf8c901756..5556006afb6 100644
--- a/dlls/win32u/win32u_private.h
+++ b/dlls/win32u/win32u_private.h
@@ -32,185 +32,1116 @@
 #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 UINT *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 );
-    struct opengl_funcs * (CDECL *get_wgl_driver)( HDC hdc, UINT version );
-    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_get_wgl_driver, 
+    unix___wine_send_input, 
+    unix_count, 
+};
+
+#pragma ms_struct on
+
+struct NtGdiAbortDoc_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiAbortPath_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiAlphaBlend_params
+{
+    HDC arg0; 
+    int arg1; 
+    int arg2; 
+    int arg3; 
+    int arg4; 
+    HDC arg5; 
+    int arg6; 
+    int arg7; 
+    int arg8; 
+    int arg9; 
+    BLENDFUNCTION arg10; 
+    HANDLE arg11; 
+};
+
+struct NtGdiAngleArc_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    DWORD arg3; 
+    FLOAT arg4; 
+    FLOAT arg5; 
+};
+
+struct NtGdiArcInternal_params
+{
+    UINT arg0; 
+    HDC arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    INT arg5; 
+    INT arg6; 
+    INT arg7; 
+    INT arg8; 
+    INT arg9; 
+};
+
+struct NtGdiBeginPath_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiBitBlt_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    HDC arg5; 
+    INT arg6; 
+    INT arg7; 
+    DWORD arg8; 
+    DWORD arg9; 
+    FLONG arg10; 
+};
+
+struct NtGdiCloseFigure_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiComputeXformCoefficients_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiCreateCompatibleBitmap_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    HBITMAP result;
+};
+
+struct NtGdiCreateCompatibleDC_params
+{
+    HDC arg0; 
+    HDC result;
+};
+
+struct NtGdiCreateDIBitmapInternal_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    DWORD arg3; 
+    const void *arg4; 
+    const BITMAPINFO *arg5; 
+    UINT arg6; 
+    UINT arg7; 
+    UINT arg8; 
+    ULONG arg9; 
+    HANDLE arg10; 
+    HBITMAP result;
+};
+
+struct NtGdiCreateMetafileDC_params
+{
+    HDC arg0; 
+    HDC result;
+};
+
+struct NtGdiDdDDICheckVidPnExclusiveOwnership_params
+{
+    const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *arg0; 
+};
+
+struct NtGdiDdDDICloseAdapter_params
+{
+    const D3DKMT_CLOSEADAPTER *arg0; 
+};
+
+struct NtGdiDdDDICreateDCFromMemory_params
+{
+    D3DKMT_CREATEDCFROMMEMORY *arg0; 
+};
+
+struct NtGdiDdDDIDestroyDCFromMemory_params
+{
+    const D3DKMT_DESTROYDCFROMMEMORY *arg0; 
+};
+
+struct NtGdiDdDDIDestroyDevice_params
+{
+    const D3DKMT_DESTROYDEVICE *arg0; 
+};
+
+struct NtGdiDdDDIEscape_params
+{
+    const D3DKMT_ESCAPE *arg0; 
+};
+
+struct NtGdiDdDDIOpenAdapterFromDeviceName_params
+{
+    D3DKMT_OPENADAPTERFROMDEVICENAME *arg0; 
+};
+
+struct NtGdiDdDDIOpenAdapterFromLuid_params
+{
+    D3DKMT_OPENADAPTERFROMLUID *arg0; 
+};
+
+struct NtGdiDdDDIQueryVideoMemoryInfo_params
+{
+    D3DKMT_QUERYVIDEOMEMORYINFO *arg0; 
+};
+
+struct NtGdiDdDDISetVidPnSourceOwner_params
+{
+    const D3DKMT_SETVIDPNSOURCEOWNER *arg0; 
+};
+
+struct NtGdiDeleteObjectApp_params
+{
+    HGDIOBJ arg0; 
+};
+
+struct NtGdiDoPalette_params
+{
+    HGDIOBJ arg0; 
+    WORD arg1; 
+    WORD arg2; 
+    void *arg3; 
+    DWORD arg4; 
+    BOOL arg5; 
+};
+
+struct NtGdiEllipse_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+};
+
+struct NtGdiEndDoc_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiEndPage_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiEndPath_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiEnumFonts_params
+{
+    HDC arg0; 
+    ULONG arg1; 
+    ULONG arg2; 
+    ULONG arg3; 
+    const WCHAR *arg4; 
+    ULONG arg5; 
+    ULONG *arg6; 
+    void *arg7; 
+};
+
+struct NtGdiExcludeClipRect_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+};
+
+struct NtGdiExtEscape_params
+{
+    HDC arg0; 
+    WCHAR *arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    const char *arg5; 
+    INT arg6; 
+    char *arg7; 
+};
+
+struct NtGdiExtFloodFill_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    COLORREF arg3; 
+    UINT arg4; 
+};
+
+struct NtGdiExtSelectClipRgn_params
+{
+    HDC arg0; 
+    HRGN arg1; 
+    INT arg2; 
+};
+
+struct NtGdiExtTextOutW_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    UINT arg3; 
+    const RECT *arg4; 
+    const WCHAR *arg5; 
+    UINT arg6; 
+    const INT *arg7; 
+    DWORD arg8; 
+};
+
+struct NtGdiFillPath_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiFillRgn_params
+{
+    HDC arg0; 
+    HRGN arg1; 
+    HBRUSH arg2; 
+};
+
+struct NtGdiFontIsLinked_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiFrameRgn_params
+{
+    HDC arg0; 
+    HRGN arg1; 
+    HBRUSH arg2; 
+    INT arg3; 
+    INT arg4; 
+};
+
+struct NtGdiGetAndSetDCDword_params
+{
+    HDC arg0; 
+    UINT arg1; 
+    DWORD arg2; 
+    DWORD *arg3; 
+};
+
+struct NtGdiGetAppClipBox_params
+{
+    HDC arg0; 
+    RECT *arg1; 
+};
+
+struct NtGdiGetBoundsRect_params
+{
+    HDC arg0; 
+    RECT *arg1; 
+    UINT arg2; 
+};
+
+struct NtGdiGetCharABCWidthsW_params
+{
+    HDC arg0; 
+    UINT arg1; 
+    UINT arg2; 
+    WCHAR *arg3; 
+    ULONG arg4; 
+    void *arg5; 
+};
+
+struct NtGdiGetCharWidthInfo_params
+{
+    HDC arg0; 
+    struct char_width_info *arg1; 
+};
+
+struct NtGdiGetCharWidthW_params
+{
+    HDC arg0; 
+    UINT arg1; 
+    UINT arg2; 
+    WCHAR *arg3; 
+    ULONG arg4; 
+    void *arg5; 
+};
+
+struct NtGdiGetDIBitsInternal_params
+{
+    HDC arg0; 
+    HBITMAP arg1; 
+    UINT arg2; 
+    UINT arg3; 
+    void *arg4; 
+    BITMAPINFO *arg5; 
+    UINT arg6; 
+    UINT arg7; 
+    UINT arg8; 
+};
+
+struct NtGdiGetDeviceCaps_params
+{
+    HDC arg0; 
+    INT arg1; 
+};
+
+struct NtGdiGetDeviceGammaRamp_params
+{
+    HDC arg0; 
+    void *arg1; 
+};
+
+struct NtGdiGetFontData_params
+{
+    HDC arg0; 
+    DWORD arg1; 
+    DWORD arg2; 
+    void *arg3; 
+    DWORD arg4; 
+};
+
+struct NtGdiGetFontUnicodeRanges_params
+{
+    HDC arg0; 
+    GLYPHSET *arg1; 
+};
+
+struct NtGdiGetGlyphIndicesW_params
+{
+    HDC arg0; 
+    const WCHAR *arg1; 
+    INT arg2; 
+    WORD *arg3; 
+    DWORD arg4; 
+};
+
+struct NtGdiGetGlyphOutline_params
+{
+    HDC arg0; 
+    UINT arg1; 
+    UINT arg2; 
+    GLYPHMETRICS *arg3; 
+    DWORD arg4; 
+    void *arg5; 
+    const MAT2 *arg6; 
+    BOOL arg7; 
+};
+
+struct NtGdiGetKerningPairs_params
+{
+    HDC arg0; 
+    DWORD arg1; 
+    KERNINGPAIR *arg2; 
+};
+
+struct NtGdiGetNearestColor_params
+{
+    HDC arg0; 
+    COLORREF arg1; 
+    COLORREF result;
+};
+
+struct NtGdiGetOutlineTextMetricsInternalW_params
+{
+    HDC arg0; 
+    UINT arg1; 
+    OUTLINETEXTMETRICW *arg2; 
+    ULONG arg3; 
+};
+
+struct NtGdiGetPixel_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    COLORREF result;
+};
+
+struct NtGdiGetRandomRgn_params
+{
+    HDC arg0; 
+    HRGN arg1; 
+    INT arg2; 
+};
+
+struct NtGdiGetRasterizerCaps_params
+{
+    RASTERIZER_STATUS *arg0; 
+    UINT arg1; 
+};
+
+struct NtGdiGetRealizationInfo_params
+{
+    HDC arg0; 
+    struct font_realization_info *arg1; 
+};
+
+struct NtGdiGetTextCharsetInfo_params
+{
+    HDC arg0; 
+    FONTSIGNATURE *arg1; 
+    DWORD arg2; 
 };
 
+struct NtGdiGetTextExtentExW_params
+{
+    HDC arg0; 
+    const WCHAR *arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT *arg4; 
+    INT *arg5; 
+    SIZE *arg6; 
+    UINT arg7; 
+};
+
+struct NtGdiGetTextFaceW_params
+{
+    HDC arg0; 
+    INT arg1; 
+    WCHAR *arg2; 
+    BOOL arg3; 
+};
+
+struct NtGdiGetTextMetricsW_params
+{
+    HDC arg0; 
+    TEXTMETRICW *arg1; 
+    ULONG arg2; 
+};
+
+struct NtGdiGradientFill_params
+{
+    HDC arg0; 
+    TRIVERTEX *arg1; 
+    ULONG arg2; 
+    void *arg3; 
+    ULONG arg4; 
+    ULONG arg5; 
+};
+
+struct NtGdiIntersectClipRect_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+};
+
+struct NtGdiInvertRgn_params
+{
+    HDC arg0; 
+    HRGN arg1; 
+};
+
+struct NtGdiLineTo_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+};
+
+struct NtGdiMaskBlt_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    HDC arg5; 
+    INT arg6; 
+    INT arg7; 
+    HBITMAP arg8; 
+    INT arg9; 
+    INT arg10; 
+    DWORD arg11; 
+    DWORD arg12; 
+};
+
+struct NtGdiModifyWorldTransform_params
+{
+    HDC arg0; 
+    const XFORM *arg1; 
+    DWORD arg2; 
+};
+
+struct NtGdiMoveTo_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    POINT *arg3; 
+};
+
+struct NtGdiOffsetClipRgn_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+};
+
+struct NtGdiOpenDCW_params
+{
+    UNICODE_STRING *arg0; 
+    const DEVMODEW *arg1; 
+    UNICODE_STRING *arg2; 
+    ULONG arg3; 
+    BOOL arg4; 
+    HANDLE arg5; 
+    DRIVER_INFO_2W *arg6; 
+    void *arg7; 
+    HDC result;
+};
+
+struct NtGdiPatBlt_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    DWORD arg5; 
+};
+
+struct NtGdiPlgBlt_params
+{
+    HDC arg0; 
+    const POINT *arg1; 
+    HDC arg2; 
+    INT arg3; 
+    INT arg4; 
+    INT arg5; 
+    INT arg6; 
+    HBITMAP arg7; 
+    INT arg8; 
+    INT arg9; 
+    DWORD arg10; 
+};
+
+struct NtGdiPolyDraw_params
+{
+    HDC arg0; 
+    const POINT *arg1; 
+    const BYTE *arg2; 
+    DWORD arg3; 
+};
+
+struct NtGdiPolyPolyDraw_params
+{
+    HDC arg0; 
+    const POINT *arg1; 
+    const ULONG *arg2; 
+    DWORD arg3; 
+    UINT arg4; 
+};
+
+struct NtGdiPtVisible_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+};
+
+struct NtGdiRectVisible_params
+{
+    HDC arg0; 
+    const RECT *arg1; 
+};
+
+struct NtGdiRectangle_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+};
+
+struct NtGdiResetDC_params
+{
+    HDC arg0; 
+    const DEVMODEW *arg1; 
+    BOOL *arg2; 
+    DRIVER_INFO_2W *arg3; 
+    void *arg4; 
+};
+
+struct NtGdiResizePalette_params
+{
+    HPALETTE arg0; 
+    UINT arg1; 
+};
+
+struct NtGdiRestoreDC_params
+{
+    HDC arg0; 
+    INT arg1; 
+};
+
+struct NtGdiRoundRect_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    INT arg5; 
+    INT arg6; 
+};
+
+struct NtGdiScaleViewportExtEx_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    SIZE *arg5; 
+};
+
+struct NtGdiScaleWindowExtEx_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    SIZE *arg5; 
+};
+
+struct NtGdiSelectBitmap_params
+{
+    HDC arg0; 
+    HGDIOBJ arg1; 
+    HGDIOBJ result;
+};
+
+struct NtGdiSelectBrush_params
+{
+    HDC arg0; 
+    HGDIOBJ arg1; 
+    HGDIOBJ result;
+};
+
+struct NtGdiSelectClipPath_params
+{
+    HDC arg0; 
+    INT arg1; 
+};
+
+struct NtGdiSelectFont_params
+{
+    HDC arg0; 
+    HGDIOBJ arg1; 
+    HGDIOBJ result;
+};
+
+struct NtGdiSelectPen_params
+{
+    HDC arg0; 
+    HGDIOBJ arg1; 
+    HGDIOBJ result;
+};
+
+struct NtGdiSetBoundsRect_params
+{
+    HDC arg0; 
+    const RECT *arg1; 
+    UINT arg2; 
+};
+
+struct NtGdiSetDIBitsToDeviceInternal_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    DWORD arg3; 
+    DWORD arg4; 
+    INT arg5; 
+    INT arg6; 
+    UINT arg7; 
+    UINT arg8; 
+    const void *arg9; 
+    const BITMAPINFO *arg10; 
+    UINT arg11; 
+    UINT arg12; 
+    UINT arg13; 
+    BOOL arg14; 
+    HANDLE arg15; 
+};
+
+struct NtGdiSetDeviceGammaRamp_params
+{
+    HDC arg0; 
+    void *arg1; 
+};
+
+struct NtGdiSetLayout_params
+{
+    HDC arg0; 
+    LONG arg1; 
+    DWORD arg2; 
+};
+
+struct NtGdiSetPixel_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    COLORREF arg3; 
+    COLORREF result;
+};
+
+struct NtGdiSetSystemPaletteUse_params
+{
+    HDC arg0; 
+    UINT arg1; 
+};
+
+struct NtGdiStartDoc_params
+{
+    HDC arg0; 
+    const DOCINFOW *arg1; 
+    BOOL *arg2; 
+    INT arg3; 
+};
+
+struct NtGdiStartPage_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiStretchBlt_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    HDC arg5; 
+    INT arg6; 
+    INT arg7; 
+    INT arg8; 
+    INT arg9; 
+    DWORD arg10; 
+    COLORREF arg11; 
+};
+
+struct NtGdiStretchDIBitsInternal_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    INT arg3; 
+    INT arg4; 
+    INT arg5; 
+    INT arg6; 
+    INT arg7; 
+    INT arg8; 
+    const void *arg9; 
+    const BITMAPINFO *arg10; 
+    UINT arg11; 
+    DWORD arg12; 
+    UINT arg13; 
+    UINT arg14; 
+    HANDLE arg15; 
+};
+
+struct NtGdiStrokeAndFillPath_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiStrokePath_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiTransparentBlt_params
+{
+    HDC arg0; 
+    int arg1; 
+    int arg2; 
+    int arg3; 
+    int arg4; 
+    HDC arg5; 
+    int arg6; 
+    int arg7; 
+    int arg8; 
+    int arg9; 
+    UINT arg10; 
+};
+
+struct NtGdiUnrealizeObject_params
+{
+    HGDIOBJ arg0; 
+};
+
+struct NtGdiUpdateColors_params
+{
+    HDC arg0; 
+};
+
+struct NtGdiWidenPath_params
+{
+    HDC arg0; 
+};
+
+struct NtUserDrawCaptionTemp_params
+{
+    HWND arg0; 
+    HDC arg1; 
+    const RECT *arg2; 
+    HFONT arg3; 
+    HICON arg4; 
+    const WCHAR *arg5; 
+    UINT arg6; 
+};
+
+struct NtUserDrawMenuBarTemp_params
+{
+    HWND arg0; 
+    HDC arg1; 
+    RECT *arg2; 
+    HMENU arg3; 
+    HFONT arg4; 
+};
+
+struct NtUserEndPaint_params
+{
+    HWND arg0; 
+    const PAINTSTRUCT *arg1; 
+};
+
+struct NtUserExcludeUpdateRgn_params
+{
+    HDC arg0; 
+    HWND arg1; 
+};
+
+struct NtUserReleaseDC_params
+{
+    HWND arg0; 
+    HDC arg1; 
+};
+
+struct NtUserScrollDC_params
+{
+    HDC arg0; 
+    INT arg1; 
+    INT arg2; 
+    const RECT *arg3; 
+    const RECT *arg4; 
+    HRGN arg5; 
+    RECT *arg6; 
+};
+
+struct NtUserSelectPalette_params
+{
+    HDC arg0; 
+    HPALETTE arg1; 
+    WORD arg2; 
+    HPALETTE result;
+};
+
+struct NtUserUpdateLayeredWindow_params
+{
+    HWND arg0; 
+    HDC arg1; 
+    const POINT *arg2; 
+    const SIZE *arg3; 
+    HDC arg4; 
+    const POINT *arg5; 
+    COLORREF arg6; 
+    const BLENDFUNCTION *arg7; 
+    DWORD arg8; 
+    const RECT *arg9; 
+};
+
+struct SetDIBits_params
+{
+    HDC arg0; 
+    HBITMAP arg1; 
+    UINT arg2; 
+    UINT arg3; 
+    LPCVOID arg4; 
+    const BITMAPINFO *arg5; 
+    UINT arg6; 
+};
+
+struct __wine_get_brush_bitmap_info_params
+{
+    HBRUSH arg0; 
+    BITMAPINFO *arg1; 
+    void *arg2; 
+    UINT *arg3; 
+};
+
+struct __wine_get_file_outline_text_metric_params
+{
+    const WCHAR *arg0; 
+    OUTLINETEXTMETRICW *arg1; 
+};
+
+struct __wine_get_icm_profile_params
+{
+    HDC arg0; 
+    BOOL arg1; 
+    DWORD *arg2; 
+    WCHAR *arg3; 
+};
+
+struct __wine_get_wgl_driver_params
+{
+    HDC arg0; 
+    UINT arg1; 
+    struct opengl_funcs * result;
+};
+
+struct __wine_send_input_params
+{
+    HWND arg0; 
+    const INPUT *arg1; 
+    const RAWINPUT *arg2; 
+};
+
+#pragma ms_struct reset
+
 /* clipboard.c */
 extern UINT enum_clipboard_formats( UINT format ) DECLSPEC_HIDDEN;
 extern void release_clipboard_owner( HWND hwnd ) DECLSPEC_HIDDEN;
@@ -411,7 +1342,6 @@ static inline void release_win_ptr( struct tagWND *ptr )
 
 extern void wrappers_init( unixlib_handle_t handle ) DECLSPEC_HIDDEN;
 extern NTSTATUS gdi_init(void) DECLSPEC_HIDDEN;
-extern NTSTATUS callbacks_init( void *args ) DECLSPEC_HIDDEN;
 extern void winstation_init(void) DECLSPEC_HIDDEN;
 extern void sysparams_init(void) DECLSPEC_HIDDEN;
 extern int muldiv( int a, int b, int c ) DECLSPEC_HIDDEN;
diff --git a/dlls/win32u/wrappers.c b/dlls/win32u/wrappers.c
index c5078c8a7f7..d47ff5da249 100644
--- a/dlls/win32u/wrappers.c
+++ b/dlls/win32u/wrappers.c
@@ -22,796 +22,745 @@
 #define WIN32_NO_STATUS
 #include "win32u_private.h"
 
-static const struct unix_funcs *unix_funcs;
+static unixlib_handle_t unix_handle;
 
-INT WINAPI NtGdiAbortDoc( HDC hdc )
+#define win32u_unix_call(func, params) __wine_unix_call(unix_handle, func, params)
+
+INT WINAPI NtGdiAbortDoc(HDC arg0)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiAbortDoc( hdc );
+    struct NtGdiAbortDoc_params params = { arg0 };
+    return (INT)win32u_unix_call(unix_NtGdiAbortDoc, ¶ms);
 }
 
-BOOL WINAPI NtGdiAbortPath( HDC hdc )
+BOOL WINAPI NtGdiAbortPath(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiAbortPath( hdc );
+    struct NtGdiAbortPath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiAbortPath, ¶ms);
 }
 
-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 )
+BOOL WINAPI NtGdiAlphaBlend(HDC arg0, int arg1, int arg2, int arg3, int arg4, HDC arg5, int arg6, int arg7, int arg8, int arg9, BLENDFUNCTION arg10, HANDLE arg11)
 {
-    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 );
+    struct NtGdiAlphaBlend_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11 };
+    return (BOOL)win32u_unix_call(unix_NtGdiAlphaBlend, ¶ms);
 }
 
-BOOL WINAPI NtGdiAngleArc( HDC hdc, INT x, INT y, DWORD radius, FLOAT start_angle, FLOAT sweep_angle )
+BOOL WINAPI NtGdiAngleArc(HDC arg0, INT arg1, INT arg2, DWORD arg3, FLOAT arg4, FLOAT arg5)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiAngleArc( hdc, x, y, radius, start_angle, sweep_angle );
+    struct NtGdiAngleArc_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiAngleArc, ¶ms);
 }
 
-BOOL WINAPI NtGdiArcInternal( UINT type, HDC hdc, INT left, INT top, INT right, INT bottom,
-                              INT xstart, INT ystart, INT xend, INT yend )
+BOOL WINAPI NtGdiArcInternal(UINT arg0, HDC arg1, INT arg2, INT arg3, INT arg4, INT arg5, INT arg6, INT arg7, INT arg8, INT arg9)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiArcInternal( type, hdc, left, top, right, bottom, xstart, ystart, xend, yend );
+    struct NtGdiArcInternal_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 };
+    return (BOOL)win32u_unix_call(unix_NtGdiArcInternal, ¶ms);
 }
 
-BOOL WINAPI NtGdiBeginPath( HDC hdc )
+BOOL WINAPI NtGdiBeginPath(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiBeginPath( hdc );
+    struct NtGdiBeginPath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiBeginPath, ¶ms);
 }
 
-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 )
+BOOL WINAPI NtGdiBitBlt(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, HDC arg5, INT arg6, INT arg7, DWORD arg8, DWORD arg9, FLONG arg10)
 {
-    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 );
+    struct NtGdiBitBlt_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 };
+    return (BOOL)win32u_unix_call(unix_NtGdiBitBlt, ¶ms);
 }
 
-BOOL WINAPI NtGdiCloseFigure( HDC hdc )
+BOOL WINAPI NtGdiCloseFigure(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiCloseFigure( hdc );
+    struct NtGdiCloseFigure_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiCloseFigure, ¶ms);
 }
 
-BOOL WINAPI NtGdiComputeXformCoefficients( HDC hdc )
+BOOL WINAPI NtGdiComputeXformCoefficients(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiComputeXformCoefficients( hdc );
+    struct NtGdiComputeXformCoefficients_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiComputeXformCoefficients, ¶ms);
 }
 
-HBITMAP WINAPI NtGdiCreateCompatibleBitmap( HDC hdc, INT width, INT height )
+HBITMAP WINAPI NtGdiCreateCompatibleBitmap(HDC arg0, INT arg1, INT arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateCompatibleBitmap( hdc, width, height );
+    struct NtGdiCreateCompatibleBitmap_params params = { arg0, arg1, arg2 };
+    win32u_unix_call(unix_NtGdiCreateCompatibleBitmap, ¶ms);
+    return params.result;
 }
 
-HDC WINAPI NtGdiCreateCompatibleDC( HDC hdc )
+HDC WINAPI NtGdiCreateCompatibleDC(HDC arg0)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateCompatibleDC( hdc );
+    struct NtGdiCreateCompatibleDC_params params = { arg0 };
+    win32u_unix_call(unix_NtGdiCreateCompatibleDC, ¶ms);
+    return params.result;
 }
 
-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 )
+HBITMAP WINAPI NtGdiCreateDIBitmapInternal(HDC arg0, INT arg1, INT arg2, DWORD arg3, const void *arg4, const BITMAPINFO *arg5, UINT arg6, UINT arg7, UINT arg8, ULONG arg9, HANDLE arg10)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateDIBitmapInternal( hdc, width, height, init, bits, data,
-                                                     coloruse, max_info, max_bits, flags, xform );
+    struct NtGdiCreateDIBitmapInternal_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 };
+    win32u_unix_call(unix_NtGdiCreateDIBitmapInternal, ¶ms);
+    return params.result;
 }
 
-HDC WINAPI NtGdiCreateMetafileDC( HDC hdc )
+HDC WINAPI NtGdiCreateMetafileDC(HDC arg0)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateMetafileDC( hdc );
+    struct NtGdiCreateMetafileDC_params params = { arg0 };
+    win32u_unix_call(unix_NtGdiCreateMetafileDC, ¶ms);
+    return params.result;
 }
 
-BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj )
+NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiDeleteObjectApp( obj );
+    struct NtGdiDdDDICheckVidPnExclusiveOwnership_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDICheckVidPnExclusiveOwnership, ¶ms);
 }
 
-LONG WINAPI NtGdiDoPalette( HGDIOBJ handle, WORD start, WORD count, void *entries,
-                            DWORD func, BOOL inbound )
+NTSTATUS WINAPI NtGdiDdDDICloseAdapter(const D3DKMT_CLOSEADAPTER *arg0)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiDoPalette( handle, start, count, entries, func, inbound );
+    struct NtGdiDdDDICloseAdapter_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDICloseAdapter, ¶ms);
 }
 
-BOOL WINAPI NtGdiEllipse( HDC hdc, INT left, INT top, INT right, INT bottom )
+NTSTATUS WINAPI NtGdiDdDDICreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiEllipse( hdc, left, top, right, bottom );
+    struct NtGdiDdDDICreateDCFromMemory_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDICreateDCFromMemory, ¶ms);
 }
 
-INT WINAPI NtGdiEndDoc( HDC hdc )
+NTSTATUS WINAPI NtGdiDdDDIDestroyDCFromMemory(const D3DKMT_DESTROYDCFROMMEMORY *arg0)
 {
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiEndDoc( hdc );
+    struct NtGdiDdDDIDestroyDCFromMemory_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDIDestroyDCFromMemory, ¶ms);
 }
 
-BOOL WINAPI NtGdiEndPath( HDC hdc )
+NTSTATUS WINAPI NtGdiDdDDIDestroyDevice(const D3DKMT_DESTROYDEVICE *arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiEndPath( hdc );
+    struct NtGdiDdDDIDestroyDevice_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDIDestroyDevice, ¶ms);
 }
 
-INT WINAPI NtGdiEndPage( HDC hdc )
+NTSTATUS WINAPI NtGdiDdDDIEscape(const D3DKMT_ESCAPE *arg0)
 {
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiEndPage( hdc );
+    struct NtGdiDdDDIEscape_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDIEscape, ¶ms);
 }
 
-BOOL WINAPI NtUserEndPaint( HWND hwnd, const PAINTSTRUCT *ps )
+NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName(D3DKMT_OPENADAPTERFROMDEVICENAME *arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserEndPaint( hwnd, ps );
+    struct NtGdiDdDDIOpenAdapterFromDeviceName_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDIOpenAdapterFromDeviceName, ¶ms);
 }
 
-BOOL WINAPI NtGdiEnumFonts( HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len,
-                            const WCHAR *face_name, ULONG charset, ULONG *count, void *buf )
+NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid(D3DKMT_OPENADAPTERFROMLUID *arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiEnumFonts( hdc, type, win32_compat, face_name_len, face_name,
-                                        charset, count, buf );
+    struct NtGdiDdDDIOpenAdapterFromLuid_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDIOpenAdapterFromLuid, ¶ms);
 }
 
-INT WINAPI NtGdiExcludeClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
+NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo(D3DKMT_QUERYVIDEOMEMORYINFO *arg0)
 {
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiExcludeClipRect( hdc, left, top, right, bottom );
+    struct NtGdiDdDDIQueryVideoMemoryInfo_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDIQueryVideoMemoryInfo, ¶ms);
 }
 
-INT WINAPI NtGdiExtEscape( HDC hdc, WCHAR *driver, INT driver_id, INT escape, INT input_size,
-                           const char *input, INT output_size, char *output )
+NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner(const D3DKMT_SETVIDPNSOURCEOWNER *arg0)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiExtEscape( hdc, driver, driver_id, escape, input_size, input,
-                                        output_size, output );
+    struct NtGdiDdDDISetVidPnSourceOwner_params params = { arg0 };
+    return win32u_unix_call(unix_NtGdiDdDDISetVidPnSourceOwner, ¶ms);
 }
 
-BOOL WINAPI NtGdiExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT type )
+BOOL WINAPI NtGdiDeleteObjectApp(HGDIOBJ arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiExtFloodFill( hdc, x, y, color, type );
+    struct NtGdiDeleteObjectApp_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiDeleteObjectApp, ¶ms);
 }
 
-BOOL WINAPI NtGdiExtTextOutW( HDC hdc, INT x, INT y, UINT flags, const RECT *rect,
-                              const WCHAR *str, UINT count, const INT *dx, DWORD cp )
+LONG WINAPI NtGdiDoPalette(HGDIOBJ arg0, WORD arg1, WORD arg2, void *arg3, DWORD arg4, BOOL arg5)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiExtTextOutW( hdc, x, y, flags, rect, str, count, dx, cp );
+    struct NtGdiDoPalette_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (LONG)win32u_unix_call(unix_NtGdiDoPalette, ¶ms);
 }
 
-INT WINAPI NtGdiExtSelectClipRgn( HDC hdc, HRGN region, INT mode )
+BOOL WINAPI NtGdiEllipse(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4)
 {
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiExtSelectClipRgn( hdc, region, mode );
+    struct NtGdiEllipse_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (BOOL)win32u_unix_call(unix_NtGdiEllipse, ¶ms);
 }
 
-BOOL WINAPI NtGdiFillPath( HDC hdc )
+INT WINAPI NtGdiEndDoc(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFillPath( hdc );
+    struct NtGdiEndDoc_params params = { arg0 };
+    return (INT)win32u_unix_call(unix_NtGdiEndDoc, ¶ms);
 }
 
-BOOL WINAPI NtGdiFillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
+INT WINAPI NtGdiEndPage(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFillRgn( hdc, hrgn, hbrush );
+    struct NtGdiEndPage_params params = { arg0 };
+    return (INT)win32u_unix_call(unix_NtGdiEndPage, ¶ms);
 }
 
-BOOL WINAPI NtGdiFontIsLinked( HDC hdc )
+BOOL WINAPI NtGdiEndPath(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFontIsLinked( hdc );
+    struct NtGdiEndPath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiEndPath, ¶ms);
 }
 
-BOOL WINAPI NtGdiFrameRgn( HDC hdc, HRGN hrgn, HBRUSH brush, INT width, INT height )
+BOOL WINAPI NtGdiEnumFonts(HDC arg0, ULONG arg1, ULONG arg2, ULONG arg3, const WCHAR *arg4, ULONG arg5, ULONG *arg6, void *arg7)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFrameRgn( hdc, hrgn, brush, width, height );
+    struct NtGdiEnumFonts_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
+    return (BOOL)win32u_unix_call(unix_NtGdiEnumFonts, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetAndSetDCDword( HDC hdc, UINT method, DWORD value, DWORD *result )
+INT WINAPI NtGdiExcludeClipRect(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetAndSetDCDword( hdc, method, value, result );
+    struct NtGdiExcludeClipRect_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (INT)win32u_unix_call(unix_NtGdiExcludeClipRect, ¶ms);
 }
 
-INT WINAPI NtGdiGetAppClipBox( HDC hdc, RECT *rect )
+INT WINAPI NtGdiExtEscape(HDC arg0, WCHAR *arg1, INT arg2, INT arg3, INT arg4, const char *arg5, INT arg6, char *arg7)
 {
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiGetAppClipBox( hdc, rect );
+    struct NtGdiExtEscape_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
+    return (INT)win32u_unix_call(unix_NtGdiExtEscape, ¶ms);
 }
 
-UINT WINAPI NtGdiGetBoundsRect( HDC hdc, RECT *rect, UINT flags )
+BOOL WINAPI NtGdiExtFloodFill(HDC arg0, INT arg1, INT arg2, COLORREF arg3, UINT arg4)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetBoundsRect( hdc, rect, flags );
+    struct NtGdiExtFloodFill_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (BOOL)win32u_unix_call(unix_NtGdiExtFloodFill, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetCharABCWidthsW( HDC hdc, UINT first, UINT last, WCHAR *chars,
-                                    ULONG flags, void *buffer )
+INT WINAPI NtGdiExtSelectClipRgn(HDC arg0, HRGN arg1, INT arg2)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetCharABCWidthsW( hdc, first, last, chars, flags, buffer );
+    struct NtGdiExtSelectClipRgn_params params = { arg0, arg1, arg2 };
+    return (INT)win32u_unix_call(unix_NtGdiExtSelectClipRgn, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetCharWidthW( HDC hdc, UINT first_char, UINT last_char, WCHAR *chars,
-                                ULONG flags, void *buffer )
+BOOL WINAPI NtGdiExtTextOutW(HDC arg0, INT arg1, INT arg2, UINT arg3, const RECT *arg4, const WCHAR *arg5, UINT arg6, const INT *arg7, DWORD arg8)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetCharWidthW( hdc, first_char, last_char, chars, flags, buffer );
+    struct NtGdiExtTextOutW_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 };
+    return (BOOL)win32u_unix_call(unix_NtGdiExtTextOutW, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetCharWidthInfo( HDC hdc, struct char_width_info *info )
+BOOL WINAPI NtGdiFillPath(HDC arg0)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetCharWidthInfo( hdc, info );
+    struct NtGdiFillPath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiFillPath, ¶ms);
 }
 
-INT WINAPI NtGdiGetDIBitsInternal( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines,
-                                   void *bits, BITMAPINFO *info, UINT coloruse,
-                                   UINT max_bits, UINT max_info )
+BOOL WINAPI NtGdiFillRgn(HDC arg0, HRGN arg1, HBRUSH arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetDIBitsInternal( hdc, hbitmap, startscan, lines, bits, info, coloruse,
-                                                max_bits, max_info );
+    struct NtGdiFillRgn_params params = { arg0, arg1, arg2 };
+    return (BOOL)win32u_unix_call(unix_NtGdiFillRgn, ¶ms);
 }
 
-INT WINAPI NtGdiGetDeviceCaps( HDC hdc, INT cap )
+BOOL WINAPI NtGdiFontIsLinked(HDC arg0)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetDeviceCaps( hdc, cap );
+    struct NtGdiFontIsLinked_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiFontIsLinked, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetDeviceGammaRamp( HDC hdc, void *ptr )
+BOOL WINAPI NtGdiFrameRgn(HDC arg0, HRGN arg1, HBRUSH arg2, INT arg3, INT arg4)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetDeviceGammaRamp( hdc, ptr );
+    struct NtGdiFrameRgn_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (BOOL)win32u_unix_call(unix_NtGdiFrameRgn, ¶ms);
 }
 
-DWORD WINAPI NtGdiGetFontData( HDC hdc, DWORD table, DWORD offset, void *buffer, DWORD length )
+BOOL WINAPI NtGdiGetAndSetDCDword(HDC arg0, UINT arg1, DWORD arg2, DWORD *arg3)
 {
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiGetFontData( hdc, table, offset, buffer, length );
+    struct NtGdiGetAndSetDCDword_params params = { arg0, arg1, arg2, arg3 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetAndSetDCDword, ¶ms);
 }
 
-DWORD WINAPI NtGdiGetFontUnicodeRanges( HDC hdc, GLYPHSET *lpgs )
+INT WINAPI NtGdiGetAppClipBox(HDC arg0, RECT *arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetFontUnicodeRanges( hdc, lpgs );
+    struct NtGdiGetAppClipBox_params params = { arg0, arg1 };
+    return (INT)win32u_unix_call(unix_NtGdiGetAppClipBox, ¶ms);
 }
 
-DWORD WINAPI NtGdiGetGlyphIndicesW( HDC hdc, const WCHAR *str, INT count,
-                                    WORD *indices, DWORD flags )
+UINT WINAPI NtGdiGetBoundsRect(HDC arg0, RECT *arg1, UINT arg2)
 {
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiGetGlyphIndicesW( hdc, str, count, indices, flags );
+    struct NtGdiGetBoundsRect_params params = { arg0, arg1, arg2 };
+    return (UINT)win32u_unix_call(unix_NtGdiGetBoundsRect, ¶ms);
 }
 
-DWORD WINAPI NtGdiGetGlyphOutline( HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics,
-                                   DWORD size, void *buffer, const MAT2 *mat2,
-                                   BOOL ignore_rotation )
+BOOL WINAPI NtGdiGetCharABCWidthsW(HDC arg0, UINT arg1, UINT arg2, WCHAR *arg3, ULONG arg4, void *arg5)
 {
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiGetGlyphOutline( hdc, ch, format, metrics, size, buffer, mat2, ignore_rotation );
+    struct NtGdiGetCharABCWidthsW_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetCharABCWidthsW, ¶ms);
 }
 
-DWORD WINAPI NtGdiGetKerningPairs( HDC hdc, DWORD count, KERNINGPAIR *kern_pair )
+BOOL WINAPI NtGdiGetCharWidthInfo(HDC arg0, struct char_width_info *arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetKerningPairs( hdc, count, kern_pair );
+    struct NtGdiGetCharWidthInfo_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetCharWidthInfo, ¶ms);
 }
 
-COLORREF WINAPI NtGdiGetNearestColor( HDC hdc, COLORREF color )
+BOOL WINAPI NtGdiGetCharWidthW(HDC arg0, UINT arg1, UINT arg2, WCHAR *arg3, ULONG arg4, void *arg5)
 {
-    if (!unix_funcs) return CLR_INVALID;
-    return unix_funcs->pNtGdiGetNearestColor( hdc, color );
+    struct NtGdiGetCharWidthW_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetCharWidthW, ¶ms);
 }
 
-UINT WINAPI NtGdiGetOutlineTextMetricsInternalW( HDC hdc, UINT cbData,
-                                                 OUTLINETEXTMETRICW *otm, ULONG opts )
+INT WINAPI NtGdiGetDIBitsInternal(HDC arg0, HBITMAP arg1, UINT arg2, UINT arg3, void *arg4, BITMAPINFO *arg5, UINT arg6, UINT arg7, UINT arg8)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetOutlineTextMetricsInternalW( hdc, cbData, otm, opts );
+    struct NtGdiGetDIBitsInternal_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 };
+    return (INT)win32u_unix_call(unix_NtGdiGetDIBitsInternal, ¶ms);
 }
 
-COLORREF WINAPI NtGdiGetPixel( HDC hdc, INT x, INT y )
+INT WINAPI NtGdiGetDeviceCaps(HDC arg0, INT arg1)
 {
-    if (!unix_funcs) return CLR_INVALID;
-    return unix_funcs->pNtGdiGetPixel( hdc, x, y );
+    struct NtGdiGetDeviceCaps_params params = { arg0, arg1 };
+    return (INT)win32u_unix_call(unix_NtGdiGetDeviceCaps, ¶ms);
 }
 
-INT WINAPI NtGdiGetRandomRgn( HDC hdc, HRGN region, INT code )
+BOOL WINAPI NtGdiGetDeviceGammaRamp(HDC arg0, void *arg1)
 {
-    if (!unix_funcs) return -1;
-    return unix_funcs->pNtGdiGetRandomRgn( hdc, region, code );
+    struct NtGdiGetDeviceGammaRamp_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetDeviceGammaRamp, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetRasterizerCaps( RASTERIZER_STATUS *status, UINT size )
+DWORD WINAPI NtGdiGetFontData(HDC arg0, DWORD arg1, DWORD arg2, void *arg3, DWORD arg4)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetRasterizerCaps( status, size );
+    struct NtGdiGetFontData_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (DWORD)win32u_unix_call(unix_NtGdiGetFontData, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetRealizationInfo( HDC hdc, struct font_realization_info *info )
+DWORD WINAPI NtGdiGetFontUnicodeRanges(HDC arg0, GLYPHSET *arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetRealizationInfo( hdc, info );
+    struct NtGdiGetFontUnicodeRanges_params params = { arg0, arg1 };
+    return (DWORD)win32u_unix_call(unix_NtGdiGetFontUnicodeRanges, ¶ms);
 }
 
-UINT WINAPI NtGdiGetTextCharsetInfo( HDC hdc, FONTSIGNATURE *fs, DWORD flags )
+DWORD WINAPI NtGdiGetGlyphIndicesW(HDC arg0, const WCHAR *arg1, INT arg2, WORD *arg3, DWORD arg4)
 {
-    if (!unix_funcs) return DEFAULT_CHARSET;
-    return unix_funcs->pNtGdiGetTextCharsetInfo( hdc, fs, flags );
+    struct NtGdiGetGlyphIndicesW_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (DWORD)win32u_unix_call(unix_NtGdiGetGlyphIndicesW, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetTextExtentExW( HDC hdc, const WCHAR *str, INT count, INT max_ext,
-                                   INT *nfit, INT *dxs, SIZE *size, UINT flags )
+DWORD WINAPI NtGdiGetGlyphOutline(HDC arg0, UINT arg1, UINT arg2, GLYPHMETRICS *arg3, DWORD arg4, void *arg5, const MAT2 *arg6, BOOL arg7)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetTextExtentExW( hdc, str, count, max_ext, nfit, dxs, size, flags );
+    struct NtGdiGetGlyphOutline_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
+    return (DWORD)win32u_unix_call(unix_NtGdiGetGlyphOutline, ¶ms);
 }
 
-INT WINAPI NtGdiGetTextFaceW( HDC hdc, INT count, WCHAR *name, BOOL alias_name )
+DWORD WINAPI NtGdiGetKerningPairs(HDC arg0, DWORD arg1, KERNINGPAIR *arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetTextFaceW( hdc, count, name, alias_name );
+    struct NtGdiGetKerningPairs_params params = { arg0, arg1, arg2 };
+    return (DWORD)win32u_unix_call(unix_NtGdiGetKerningPairs, ¶ms);
 }
 
-BOOL WINAPI NtGdiGetTextMetricsW( HDC hdc, TEXTMETRICW *metrics, ULONG flags )
+COLORREF WINAPI NtGdiGetNearestColor(HDC arg0, COLORREF arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetTextMetricsW( hdc, metrics, flags );
+    struct NtGdiGetNearestColor_params params = { arg0, arg1 };
+    win32u_unix_call(unix_NtGdiGetNearestColor, ¶ms);
+    return params.result;
 }
 
-BOOL WINAPI NtGdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
-                               void *grad_array, ULONG ngrad, ULONG mode )
+UINT WINAPI NtGdiGetOutlineTextMetricsInternalW(HDC arg0, UINT arg1, OUTLINETEXTMETRICW *arg2, ULONG arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
+    struct NtGdiGetOutlineTextMetricsInternalW_params params = { arg0, arg1, arg2, arg3 };
+    return (UINT)win32u_unix_call(unix_NtGdiGetOutlineTextMetricsInternalW, ¶ms);
 }
 
-INT WINAPI NtGdiIntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
+COLORREF WINAPI NtGdiGetPixel(HDC arg0, INT arg1, INT arg2)
 {
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiIntersectClipRect( hdc, left, top, right, bottom );
+    struct NtGdiGetPixel_params params = { arg0, arg1, arg2 };
+    win32u_unix_call(unix_NtGdiGetPixel, ¶ms);
+    return params.result;
 }
 
-BOOL WINAPI NtGdiInvertRgn( HDC hdc, HRGN hrgn )
+INT WINAPI NtGdiGetRandomRgn(HDC arg0, HRGN arg1, INT arg2)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiInvertRgn( hdc, hrgn );
+    struct NtGdiGetRandomRgn_params params = { arg0, arg1, arg2 };
+    return (INT)win32u_unix_call(unix_NtGdiGetRandomRgn, ¶ms);
 }
 
-BOOL WINAPI NtGdiLineTo( HDC hdc, INT x, INT y )
+BOOL WINAPI NtGdiGetRasterizerCaps(RASTERIZER_STATUS *arg0, UINT arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiLineTo( hdc, x, y );
+    struct NtGdiGetRasterizerCaps_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetRasterizerCaps, ¶ms);
 }
 
-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 )
+BOOL WINAPI NtGdiGetRealizationInfo(HDC arg0, struct font_realization_info *arg1)
 {
-    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 );
+    struct NtGdiGetRealizationInfo_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetRealizationInfo, ¶ms);
 }
 
-BOOL WINAPI NtGdiModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode )
+UINT WINAPI NtGdiGetTextCharsetInfo(HDC arg0, FONTSIGNATURE *arg1, DWORD arg2)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiModifyWorldTransform( hdc, xform, mode );
+    struct NtGdiGetTextCharsetInfo_params params = { arg0, arg1, arg2 };
+    return (UINT)win32u_unix_call(unix_NtGdiGetTextCharsetInfo, ¶ms);
 }
 
-BOOL WINAPI NtGdiMoveTo( HDC hdc, INT x, INT y, POINT *pt )
+BOOL WINAPI NtGdiGetTextExtentExW(HDC arg0, const WCHAR *arg1, INT arg2, INT arg3, INT *arg4, INT *arg5, SIZE *arg6, UINT arg7)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiMoveTo( hdc, x, y, pt );
+    struct NtGdiGetTextExtentExW_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetTextExtentExW, ¶ms);
 }
 
-INT WINAPI NtGdiOffsetClipRgn( HDC hdc, INT x, INT y )
+INT WINAPI NtGdiGetTextFaceW(HDC arg0, INT arg1, WCHAR *arg2, BOOL arg3)
 {
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiOffsetClipRgn( hdc, x, y );
+    struct NtGdiGetTextFaceW_params params = { arg0, arg1, arg2, arg3 };
+    return (INT)win32u_unix_call(unix_NtGdiGetTextFaceW, ¶ms);
 }
 
-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 )
+BOOL WINAPI NtGdiGetTextMetricsW(HDC arg0, TEXTMETRICW *arg1, ULONG arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiOpenDCW( device, devmode, output, type, is_display,
-                                      hspool, driver_info, pdev );
+    struct NtGdiGetTextMetricsW_params params = { arg0, arg1, arg2 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGetTextMetricsW, ¶ms);
 }
 
-BOOL WINAPI NtGdiPatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop )
+BOOL WINAPI NtGdiGradientFill(HDC arg0, TRIVERTEX *arg1, ULONG arg2, void *arg3, ULONG arg4, ULONG arg5)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPatBlt( hdc, left, top, width, height, rop );
+    struct NtGdiGradientFill_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiGradientFill, ¶ms);
 }
 
-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 )
+INT WINAPI NtGdiIntersectClipRect(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4)
 {
-    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 );
+    struct NtGdiIntersectClipRect_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (INT)win32u_unix_call(unix_NtGdiIntersectClipRect, ¶ms);
 }
 
-BOOL WINAPI NtGdiPolyDraw( HDC hdc, const POINT *points, const BYTE *types, DWORD count )
+BOOL WINAPI NtGdiInvertRgn(HDC arg0, HRGN arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPolyDraw( hdc, points, types, count );
+    struct NtGdiInvertRgn_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiInvertRgn, ¶ms);
 }
 
-ULONG WINAPI NtGdiPolyPolyDraw( HDC hdc, const POINT *points, const ULONG *counts,
-                                DWORD count, UINT function )
+BOOL WINAPI NtGdiLineTo(HDC arg0, INT arg1, INT arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiPolyPolyDraw( hdc, points, counts, count, function );
+    struct NtGdiLineTo_params params = { arg0, arg1, arg2 };
+    return (BOOL)win32u_unix_call(unix_NtGdiLineTo, ¶ms);
 }
 
-BOOL WINAPI NtGdiPtVisible( HDC hdc, INT x, INT y )
+BOOL WINAPI NtGdiMaskBlt(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, HDC arg5, INT arg6, INT arg7, HBITMAP arg8, INT arg9, INT arg10, DWORD arg11, DWORD arg12)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPtVisible( hdc, x, y );
+    struct NtGdiMaskBlt_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12 };
+    return (BOOL)win32u_unix_call(unix_NtGdiMaskBlt, ¶ms);
 }
 
-BOOL WINAPI NtGdiRectVisible( HDC hdc, const RECT *rect )
+BOOL WINAPI NtGdiModifyWorldTransform(HDC arg0, const XFORM *arg1, DWORD arg2)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRectVisible( hdc, rect );
+    struct NtGdiModifyWorldTransform_params params = { arg0, arg1, arg2 };
+    return (BOOL)win32u_unix_call(unix_NtGdiModifyWorldTransform, ¶ms);
 }
 
-BOOL WINAPI NtGdiRectangle( HDC hdc, INT left, INT top, INT right, INT bottom )
+BOOL WINAPI NtGdiMoveTo(HDC arg0, INT arg1, INT arg2, POINT *arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRectangle( hdc, left, top, right, bottom );
+    struct NtGdiMoveTo_params params = { arg0, arg1, arg2, arg3 };
+    return (BOOL)win32u_unix_call(unix_NtGdiMoveTo, ¶ms);
 }
 
-BOOL WINAPI NtGdiResetDC( HDC hdc, const DEVMODEW *devmode, BOOL *banding,
-                          DRIVER_INFO_2W *driver_info, void *dev )
+INT WINAPI NtGdiOffsetClipRgn(HDC arg0, INT arg1, INT arg2)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiResetDC( hdc, devmode, banding, driver_info, dev );
+    struct NtGdiOffsetClipRgn_params params = { arg0, arg1, arg2 };
+    return (INT)win32u_unix_call(unix_NtGdiOffsetClipRgn, ¶ms);
 }
 
-BOOL WINAPI NtGdiResizePalette( HPALETTE palette, UINT count )
+HDC WINAPI NtGdiOpenDCW(UNICODE_STRING *arg0, const DEVMODEW *arg1, UNICODE_STRING *arg2, ULONG arg3, BOOL arg4, HANDLE arg5, DRIVER_INFO_2W *arg6, void *arg7)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiResizePalette( palette, count );
+    struct NtGdiOpenDCW_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
+    win32u_unix_call(unix_NtGdiOpenDCW, ¶ms);
+    return params.result;
 }
 
-BOOL WINAPI NtGdiRestoreDC( HDC hdc, INT level )
+BOOL WINAPI NtGdiPatBlt(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, DWORD arg5)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRestoreDC( hdc, level );
+    struct NtGdiPatBlt_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiPatBlt, ¶ms);
 }
 
-BOOL WINAPI NtGdiRoundRect( HDC hdc, INT left, INT top, INT right,
-                            INT bottom, INT ell_width, INT ell_height )
+BOOL WINAPI NtGdiPlgBlt(HDC arg0, const POINT *arg1, HDC arg2, INT arg3, INT arg4, INT arg5, INT arg6, HBITMAP arg7, INT arg8, INT arg9, DWORD arg10)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
+    struct NtGdiPlgBlt_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 };
+    return (BOOL)win32u_unix_call(unix_NtGdiPlgBlt, ¶ms);
 }
 
-BOOL WINAPI NtGdiScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom,
-                                     INT y_num, INT y_denom, SIZE *size )
+BOOL WINAPI NtGdiPolyDraw(HDC arg0, const POINT *arg1, const BYTE *arg2, DWORD arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
+    struct NtGdiPolyDraw_params params = { arg0, arg1, arg2, arg3 };
+    return (BOOL)win32u_unix_call(unix_NtGdiPolyDraw, ¶ms);
 }
 
-BOOL WINAPI NtGdiScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom,
-                                   INT y_num, INT y_denom, SIZE *size )
+ULONG WINAPI NtGdiPolyPolyDraw(HDC arg0, const POINT *arg1, const ULONG *arg2, DWORD arg3, UINT arg4)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
+    struct NtGdiPolyPolyDraw_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (ULONG)win32u_unix_call(unix_NtGdiPolyPolyDraw, ¶ms);
 }
 
-HGDIOBJ WINAPI NtGdiSelectBitmap( HDC hdc, HGDIOBJ handle )
+BOOL WINAPI NtGdiPtVisible(HDC arg0, INT arg1, INT arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectBitmap( hdc, handle );
+    struct NtGdiPtVisible_params params = { arg0, arg1, arg2 };
+    return (BOOL)win32u_unix_call(unix_NtGdiPtVisible, ¶ms);
 }
 
-HGDIOBJ WINAPI NtGdiSelectBrush( HDC hdc, HGDIOBJ handle )
+BOOL WINAPI NtGdiRectVisible(HDC arg0, const RECT *arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectBrush( hdc, handle );
+    struct NtGdiRectVisible_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiRectVisible, ¶ms);
 }
 
-BOOL WINAPI NtGdiSelectClipPath( HDC hdc, INT mode )
+BOOL WINAPI NtGdiRectangle(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiSelectClipPath( hdc, mode );
+    struct NtGdiRectangle_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (BOOL)win32u_unix_call(unix_NtGdiRectangle, ¶ms);
 }
 
-HGDIOBJ WINAPI NtGdiSelectFont( HDC hdc, HGDIOBJ handle )
+BOOL WINAPI NtGdiResetDC(HDC arg0, const DEVMODEW *arg1, BOOL *arg2, DRIVER_INFO_2W *arg3, void *arg4)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectFont( hdc, handle );
+    struct NtGdiResetDC_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (BOOL)win32u_unix_call(unix_NtGdiResetDC, ¶ms);
 }
 
-HGDIOBJ WINAPI NtGdiSelectPen( HDC hdc, HGDIOBJ handle )
+BOOL WINAPI NtGdiResizePalette(HPALETTE arg0, UINT arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectPen( hdc, handle );
+    struct NtGdiResizePalette_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiResizePalette, ¶ms);
 }
 
-UINT WINAPI NtGdiSetBoundsRect( HDC hdc, const RECT *rect, UINT flags )
+BOOL WINAPI NtGdiRestoreDC(HDC arg0, INT arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSetBoundsRect( hdc, rect, flags );
+    struct NtGdiRestoreDC_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiRestoreDC, ¶ms);
 }
 
-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 )
+BOOL WINAPI NtGdiRoundRect(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, INT arg5, INT arg6)
 {
-    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 );
+    struct NtGdiRoundRect_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6 };
+    return (BOOL)win32u_unix_call(unix_NtGdiRoundRect, ¶ms);
 }
 
-BOOL WINAPI NtGdiSetDeviceGammaRamp( HDC hdc, void *ptr )
+BOOL WINAPI NtGdiScaleViewportExtEx(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, SIZE *arg5)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiSetDeviceGammaRamp( hdc, ptr );
+    struct NtGdiScaleViewportExtEx_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiScaleViewportExtEx, ¶ms);
 }
 
-DWORD WINAPI NtGdiSetLayout( HDC hdc, LONG wox, DWORD layout )
+BOOL WINAPI NtGdiScaleWindowExtEx(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, SIZE *arg5)
 {
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiSetLayout( hdc, wox, layout );
+    struct NtGdiScaleWindowExtEx_params params = { arg0, arg1, arg2, arg3, arg4, arg5 };
+    return (BOOL)win32u_unix_call(unix_NtGdiScaleWindowExtEx, ¶ms);
 }
 
-COLORREF WINAPI NtGdiSetPixel( HDC hdc, INT x, INT y, COLORREF color )
+HGDIOBJ WINAPI NtGdiSelectBitmap(HDC arg0, HGDIOBJ arg1)
 {
-    if (!unix_funcs) return CLR_INVALID;
-    return unix_funcs->pNtGdiSetPixel( hdc, x, y, color );
+    struct NtGdiSelectBitmap_params params = { arg0, arg1 };
+    win32u_unix_call(unix_NtGdiSelectBitmap, ¶ms);
+    return params.result;
 }
 
-UINT WINAPI NtGdiSetSystemPaletteUse( HDC hdc, UINT use )
+HGDIOBJ WINAPI NtGdiSelectBrush(HDC arg0, HGDIOBJ arg1)
 {
-    if (!unix_funcs) return SYSPAL_ERROR;
-    return unix_funcs->pNtGdiSetSystemPaletteUse( hdc, use );
+    struct NtGdiSelectBrush_params params = { arg0, arg1 };
+    win32u_unix_call(unix_NtGdiSelectBrush, ¶ms);
+    return params.result;
 }
 
-INT WINAPI NtGdiStartDoc( HDC hdc, const DOCINFOW *doc, BOOL *banding, INT job )
+BOOL WINAPI NtGdiSelectClipPath(HDC arg0, INT arg1)
 {
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiStartDoc( hdc, doc, banding, job );
+    struct NtGdiSelectClipPath_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiSelectClipPath, ¶ms);
 }
 
-INT WINAPI NtGdiStartPage( HDC hdc )
+HGDIOBJ WINAPI NtGdiSelectFont(HDC arg0, HGDIOBJ arg1)
 {
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiStartPage( hdc );
+    struct NtGdiSelectFont_params params = { arg0, arg1 };
+    win32u_unix_call(unix_NtGdiSelectFont, ¶ms);
+    return params.result;
 }
 
-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 )
+HGDIOBJ WINAPI NtGdiSelectPen(HDC arg0, HGDIOBJ arg1)
 {
-    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 );
+    struct NtGdiSelectPen_params params = { arg0, arg1 };
+    win32u_unix_call(unix_NtGdiSelectPen, ¶ms);
+    return params.result;
 }
 
-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 )
+UINT WINAPI NtGdiSetBoundsRect(HDC arg0, const RECT *arg1, UINT arg2)
 {
-    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 );
+    struct NtGdiSetBoundsRect_params params = { arg0, arg1, arg2 };
+    return (UINT)win32u_unix_call(unix_NtGdiSetBoundsRect, ¶ms);
 }
 
-BOOL WINAPI NtGdiStrokeAndFillPath( HDC hdc )
+INT WINAPI NtGdiSetDIBitsToDeviceInternal(HDC arg0, INT arg1, INT arg2, DWORD arg3, DWORD arg4, INT arg5, INT arg6, UINT arg7, UINT arg8, const void *arg9, const BITMAPINFO *arg10, UINT arg11, UINT arg12, UINT arg13, BOOL arg14, HANDLE arg15)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiStrokeAndFillPath( hdc );
+    struct NtGdiSetDIBitsToDeviceInternal_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15 };
+    return (INT)win32u_unix_call(unix_NtGdiSetDIBitsToDeviceInternal, ¶ms);
 }
 
-BOOL WINAPI NtGdiStrokePath( HDC hdc )
+BOOL WINAPI NtGdiSetDeviceGammaRamp(HDC arg0, void *arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiStrokePath( hdc );
+    struct NtGdiSetDeviceGammaRamp_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtGdiSetDeviceGammaRamp, ¶ms);
 }
 
-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 )
+DWORD WINAPI NtGdiSetLayout(HDC arg0, LONG arg1, DWORD arg2)
 {
-    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 );
+    struct NtGdiSetLayout_params params = { arg0, arg1, arg2 };
+    return (DWORD)win32u_unix_call(unix_NtGdiSetLayout, ¶ms);
 }
 
-BOOL WINAPI NtGdiUnrealizeObject( HGDIOBJ obj )
+COLORREF WINAPI NtGdiSetPixel(HDC arg0, INT arg1, INT arg2, COLORREF arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiUnrealizeObject( obj );
+    struct NtGdiSetPixel_params params = { arg0, arg1, arg2, arg3 };
+    win32u_unix_call(unix_NtGdiSetPixel, ¶ms);
+    return params.result;
 }
 
-BOOL WINAPI NtGdiUpdateColors( HDC hdc )
+UINT WINAPI NtGdiSetSystemPaletteUse(HDC arg0, UINT arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiUpdateColors( hdc );
+    struct NtGdiSetSystemPaletteUse_params params = { arg0, arg1 };
+    return (UINT)win32u_unix_call(unix_NtGdiSetSystemPaletteUse, ¶ms);
 }
 
-BOOL WINAPI NtGdiWidenPath( HDC hdc )
+INT WINAPI NtGdiStartDoc(HDC arg0, const DOCINFOW *arg1, BOOL *arg2, INT arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiWidenPath( hdc );
+    struct NtGdiStartDoc_params params = { arg0, arg1, arg2, arg3 };
+    return (INT)win32u_unix_call(unix_NtGdiStartDoc, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc )
+INT WINAPI NtGdiStartPage(HDC arg0)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDICheckVidPnExclusiveOwnership( desc );
+    struct NtGdiStartPage_params params = { arg0 };
+    return (INT)win32u_unix_call(unix_NtGdiStartPage, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
+BOOL WINAPI NtGdiStretchBlt(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, HDC arg5, INT arg6, INT arg7, INT arg8, INT arg9, DWORD arg10, COLORREF arg11)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDICloseAdapter( desc );
+    struct NtGdiStretchBlt_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11 };
+    return (BOOL)win32u_unix_call(unix_NtGdiStretchBlt, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDICreateDCFromMemory( D3DKMT_CREATEDCFROMMEMORY *desc )
+INT WINAPI NtGdiStretchDIBitsInternal(HDC arg0, INT arg1, INT arg2, INT arg3, INT arg4, INT arg5, INT arg6, INT arg7, INT arg8, const void *arg9, const BITMAPINFO *arg10, UINT arg11, DWORD arg12, UINT arg13, UINT arg14, HANDLE arg15)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDICreateDCFromMemory( desc );
+    struct NtGdiStretchDIBitsInternal_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15 };
+    return (INT)win32u_unix_call(unix_NtGdiStretchDIBitsInternal, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDIDestroyDCFromMemory( const D3DKMT_DESTROYDCFROMMEMORY *desc )
+BOOL WINAPI NtGdiStrokeAndFillPath(HDC arg0)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIDestroyDCFromMemory( desc );
+    struct NtGdiStrokeAndFillPath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiStrokeAndFillPath, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc )
+BOOL WINAPI NtGdiStrokePath(HDC arg0)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIDestroyDevice( desc );
+    struct NtGdiStrokePath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiStrokePath, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDIEscape( const D3DKMT_ESCAPE *desc )
+BOOL WINAPI NtGdiTransparentBlt(HDC arg0, int arg1, int arg2, int arg3, int arg4, HDC arg5, int arg6, int arg7, int arg8, int arg9, UINT arg10)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIEscape( desc );
+    struct NtGdiTransparentBlt_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 };
+    return (BOOL)win32u_unix_call(unix_NtGdiTransparentBlt, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName( D3DKMT_OPENADAPTERFROMDEVICENAME *desc )
+BOOL WINAPI NtGdiUnrealizeObject(HGDIOBJ arg0)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIOpenAdapterFromDeviceName( desc );
+    struct NtGdiUnrealizeObject_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiUnrealizeObject, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
+BOOL WINAPI NtGdiUpdateColors(HDC arg0)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIOpenAdapterFromLuid( desc );
+    struct NtGdiUpdateColors_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiUpdateColors, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
+BOOL WINAPI NtGdiWidenPath(HDC arg0)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIQueryVideoMemoryInfo( desc );
+    struct NtGdiWidenPath_params params = { arg0 };
+    return (BOOL)win32u_unix_call(unix_NtGdiWidenPath, ¶ms);
 }
 
-NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER *desc )
+BOOL WINAPI NtUserDrawCaptionTemp(HWND arg0, HDC arg1, const RECT *arg2, HFONT arg3, HICON arg4, const WCHAR *arg5, UINT arg6)
 {
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDISetVidPnSourceOwner( desc );
+    struct NtUserDrawCaptionTemp_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6 };
+    return (BOOL)win32u_unix_call(unix_NtUserDrawCaptionTemp, ¶ms);
 }
 
-BOOL WINAPI NtUserDrawCaptionTemp( HWND hwnd, HDC hdc, const RECT *rect, HFONT font,
-                                   HICON icon, const WCHAR *str, UINT flags )
+DWORD WINAPI NtUserDrawMenuBarTemp(HWND arg0, HDC arg1, RECT *arg2, HMENU arg3, HFONT arg4)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserDrawCaptionTemp( hwnd, hdc, rect, font, icon, str, flags );
+    struct NtUserDrawMenuBarTemp_params params = { arg0, arg1, arg2, arg3, arg4 };
+    return (DWORD)win32u_unix_call(unix_NtUserDrawMenuBarTemp, ¶ms);
 }
 
-DWORD WINAPI NtUserDrawMenuBarTemp( HWND hwnd, HDC hdc, RECT *rect, HMENU handle, HFONT font )
+BOOL WINAPI NtUserEndPaint(HWND arg0, const PAINTSTRUCT *arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtUserDrawMenuBarTemp( hwnd, hdc, rect, handle, font );
+    struct NtUserEndPaint_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix_NtUserEndPaint, ¶ms);
 }
 
-INT WINAPI NtUserExcludeUpdateRgn( HDC hdc, HWND hwnd )
+INT WINAPI NtUserExcludeUpdateRgn(HDC arg0, HWND arg1)
 {
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtUserExcludeUpdateRgn( hdc, hwnd );
+    struct NtUserExcludeUpdateRgn_params params = { arg0, arg1 };
+    return (INT)win32u_unix_call(unix_NtUserExcludeUpdateRgn, ¶ms);
 }
 
-INT WINAPI NtUserReleaseDC( HWND hwnd, HDC hdc )
+INT WINAPI NtUserReleaseDC(HWND arg0, HDC arg1)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtUserReleaseDC( hwnd, hdc );
+    struct NtUserReleaseDC_params params = { arg0, arg1 };
+    return (INT)win32u_unix_call(unix_NtUserReleaseDC, ¶ms);
 }
 
-BOOL WINAPI NtUserScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
-                            HRGN ret_update_rgn, RECT *update_rect )
+BOOL WINAPI NtUserScrollDC(HDC arg0, INT arg1, INT arg2, const RECT *arg3, const RECT *arg4, HRGN arg5, RECT *arg6)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserScrollDC( hdc, dx, dy, scroll, clip, ret_update_rgn, update_rect );
+    struct NtUserScrollDC_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6 };
+    return (BOOL)win32u_unix_call(unix_NtUserScrollDC, ¶ms);
 }
 
-HPALETTE WINAPI NtUserSelectPalette( HDC hdc, HPALETTE hpal, WORD bkg )
+HPALETTE WINAPI NtUserSelectPalette(HDC arg0, HPALETTE arg1, WORD arg2)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtUserSelectPalette( hdc, hpal, bkg );
+    struct NtUserSelectPalette_params params = { arg0, arg1, arg2 };
+    win32u_unix_call(unix_NtUserSelectPalette, ¶ms);
+    return params.result;
 }
 
-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 )
+BOOL WINAPI NtUserUpdateLayeredWindow(HWND arg0, HDC arg1, const POINT *arg2, const SIZE *arg3, HDC arg4, const POINT *arg5, COLORREF arg6, const BLENDFUNCTION *arg7, DWORD arg8, const RECT *arg9)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserUpdateLayeredWindow( hwnd, hdc_dst, pts_dst, size, hdc_src, pts_src,
-                                                   key, blend, flags, dirty );
+    struct NtUserUpdateLayeredWindow_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 };
+    return (BOOL)win32u_unix_call(unix_NtUserUpdateLayeredWindow, ¶ms);
 }
 
-INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
-                      UINT lines, const void *bits, const BITMAPINFO *info,
-                      UINT coloruse )
+INT WINAPI SetDIBits(HDC arg0, HBITMAP arg1, UINT arg2, UINT arg3, LPCVOID arg4, const BITMAPINFO *arg5, UINT arg6)
 {
-    if (!unix_funcs) return 0;
-    return unix_funcs->pSetDIBits( hdc, hbitmap, startscan, lines, bits, info, coloruse );
+    struct SetDIBits_params params = { arg0, arg1, arg2, arg3, arg4, arg5, arg6 };
+    return (INT)win32u_unix_call(unix_SetDIBits, ¶ms);
 }
 
-BOOL CDECL __wine_get_icm_profile( HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename )
+BOOL CDECL __wine_get_brush_bitmap_info(HBRUSH arg0, BITMAPINFO *arg1, void *arg2, UINT *arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->get_icm_profile( hdc, allow_default, size, filename );
+    struct __wine_get_brush_bitmap_info_params params = { arg0, arg1, arg2, arg3 };
+    return (BOOL)win32u_unix_call(unix___wine_get_brush_bitmap_info, ¶ms);
 }
 
-BOOL CDECL __wine_get_brush_bitmap_info( HBRUSH handle, BITMAPINFO *info, void *bits, UINT *usage )
+BOOL CDECL __wine_get_file_outline_text_metric(const WCHAR *arg0, OUTLINETEXTMETRICW *arg1)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->get_brush_bitmap_info( handle, info, bits, usage );
+    struct __wine_get_file_outline_text_metric_params params = { arg0, arg1 };
+    return (BOOL)win32u_unix_call(unix___wine_get_file_outline_text_metric, ¶ms);
 }
 
-BOOL CDECL __wine_get_file_outline_text_metric( const WCHAR *path, OUTLINETEXTMETRICW *otm )
+BOOL CDECL __wine_get_icm_profile(HDC arg0, BOOL arg1, DWORD *arg2, WCHAR *arg3)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->get_file_outline_text_metric( path, otm );
+    struct __wine_get_icm_profile_params params = { arg0, arg1, arg2, arg3 };
+    return (BOOL)win32u_unix_call(unix___wine_get_icm_profile, ¶ms);
 }
 
-struct opengl_funcs * CDECL __wine_get_wgl_driver( HDC hdc, UINT version )
+struct opengl_funcs * CDECL __wine_get_wgl_driver(HDC arg0, UINT arg1)
 {
-    if (!unix_funcs) return NULL;
-    return unix_funcs->get_wgl_driver( hdc, version );
+    struct __wine_get_wgl_driver_params params = { arg0, arg1 };
+    win32u_unix_call(unix___wine_get_wgl_driver, ¶ms);
+    return params.result;
 }
 
-BOOL CDECL __wine_send_input( HWND hwnd, const INPUT *input, const RAWINPUT *rawinput )
+BOOL CDECL __wine_send_input(HWND arg0, const INPUT *arg1, const RAWINPUT *arg2)
 {
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->wine_send_input( hwnd, input, rawinput );
+    struct __wine_send_input_params params = { arg0, arg1, arg2 };
+    return (BOOL)win32u_unix_call(unix___wine_send_input, ¶ms);
 }
 
 extern void wrappers_init( unixlib_handle_t handle )
 {
-    const void *args;
-    if (!__wine_unix_call( handle, 1, &args )) unix_funcs = args;
+    unix_handle = handle;
 }
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/655