[PATCH v2 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.

--
  v2: win32u: replace calling unix functions by unix_call and remove callback unix_funcs

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

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

[fanwenjie]

From: fanwenjie

---
 dlls/win32u/gdiobj.c         |  132 ----
 dlls/win32u/syscall.c        |  859 ++++++++++++++++++++++-
 dlls/win32u/win32u_private.h | 1282 +++++++++++++++++++++++++++++-----
 dlls/win32u/wrappers.c       |  807 ++++++++++-----------
 4 files changed, 2338 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..01a420405b4 100644
--- a/dlls/win32u/win32u_private.h
+++ b/dlls/win32u/win32u_private.h
@@ -32,183 +32,1110 @@
 #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, 
+};
+
+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; 
 };

/* clipboard.c */
@@ -411,7 +1338,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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
+    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, &params);
+    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, &params);
+    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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
 }

-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, &params);
+    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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
+    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, &params);
 }

-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, &params);
+    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, &params);
+    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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
 }

-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, &params);
+    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, &params);
 }

extern void wrappers_init( unixlib_handle_t handle )
 {
-    const void *args;
-    if (!__wine_unix_call( handle, 1, &args )) unix_funcs = args;
+    unix_handle = handle;
 }

[Fan WenJie (＠fanwenjie)]

It generated by the script which used to parse AST file. The AST file does not contain argmument name, so argument names in function are arg+id

[Derek Lesho (＠dlesho)]

Hi Fan, from what I've seen following Jacek's recent patches, the idea is that many of these calls will eventually be implemented as their own syscalls.  __wine_unix_call is usually reserved to expose custom wine-specific functionality that isn't easily expressible through a windows-defined syscall API.  Commits like d50112b might give you an idea on how this is done.

[Zebediah Figura (she/her)]

On 8/16/22 11:15, Derek Lesho (@dlesho) wrote:
> Hi Fan, from what I've seen following Jacek's recent patches, the idea is that many of these calls will eventually be implemented as their own syscalls.  __wine_unix_call is usually reserved to expose custom wine-specific functionality that isn't easily expressible through a windows-defined syscall API.  Commits like d50112b might give you an idea on how this is done.

It's also worth pointing out that Jacek is currently working on this, 
and probably has queued patches. You may want to coördinate with him 
before sending your own patches in this area.

[Fan WenJie (＠fanwenjie)]

On Tue Aug 16 16:21:40 2022 +0000, **** wrote:
> Zebediah Figura (she/her) replied on the mailing list:
> On 8/16/22 11:15, Derek Lesho (@dlesho) wrote:
> > Hi Fan, from what I've seen following Jacek's recent patches, the idea
> is that many of these calls will eventually be implemented as their own
> syscalls.  __wine_unix_call is usually reserved to expose custom
> wine-specific functionality that isn't easily expressible through a
> windows-defined syscall API.  Commits like d50112b might give you an
> idea on how this is done.
> > 
> It's also worth pointing out that Jacek is currently working on this, 
> and probably has queued patches. You may want to co��rdinate with him 
> before sending your own patches in this area.
> _______________________________________________
> wine-gitlab mailing list -- [e-mail]
> To unsubscribe send an email to [e-mail]

Can I implement those API by syscall ? I genenrate it by script, it is so easy!

[Fan WenJie (＠fanwenjie)]

On Tue Aug 16 16:21:40 2022 +0000, **** wrote:
> Zebediah Figura (she/her) replied on the mailing list:
> On 8/16/22 11:15, Derek Lesho (@dlesho) wrote:
> > Hi Fan, from what I've seen following Jacek's recent patches, the idea
> is that many of these calls will eventually be implemented as their own
> syscalls.  __wine_unix_call is usually reserved to expose custom
> wine-specific functionality that isn't easily expressible through a
> windows-defined syscall API.  Commits like d50112b might give you an
> idea on how this is done.
> > 
> It's also worth pointing out that Jacek is currently working on this, 
> and probably has queued patches. You may want to co��rdinate with him 
> before sending your own patches in this area.
> _______________________________________________
> wine-gitlab mailing list -- [e-mail]
> To unsubscribe send an email to [e-mail]

the implementation of calling vulkan on unix in winevulkan is that using unix_call. so I do it

[Jacek Caban (＠jacek)]

On Tue Aug 16 17:09:13 2022 +0000, Fan WenJie wrote:
> the implementation of calling vulkan on unix in winevulkan is that using
> unix_call. so I do it

I already have patches converting remaining GDI functions. We can't merge those patches yet, through. Currently wineps.drv is implemented as a PE file and it implements a DC driver. This means that we're still potentially calling PE code from win32u and that's not going to work from inside a syscall (the same is true for this MR).

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

[Huw Davies (＠huw)]

This merge request was closed by Huw Davies.