wine/dlls/wow64win/gdi.c

/*
 * WoW64 GDI functions
 *
 * Copyright 2021 Jacek Caban for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include <stdarg.h>

#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winbase.h"
#include "ntgdi.h"
#include "ddk/d3dkmthk.h"
#include "wow64win_private.h"

typedef struct
{
    INT   bmType;
    INT   bmWidth;
    INT   bmHeight;
    INT   bmWidthBytes;
    WORD  bmPlanes;
    WORD  bmBitsPixel;
    ULONG bmBits;
} BITMAP32;

typedef struct
{
    DWORD    elpPenStyle;
    DWORD    elpWidth;
    UINT     elpBrushStyle;
    COLORREF elpColor;
    ULONG    elpHatch;
    DWORD    elpNumEntries;
    DWORD    elpStyleEntry[1];
} EXTLOGPEN32;

typedef struct
{
    UINT          otmSize;
    TEXTMETRICW   otmTextMetrics;
    BYTE          otmFiller;
    PANOSE        otmPanoseNumber;
    UINT          otmfsSelection;
    UINT          otmfsType;
    INT           otmsCharSlopeRise;
    INT           otmsCharSlopeRun;
    INT           otmItalicAngle;
    UINT          otmEMSquare;
    INT           otmAscent;
    INT           otmDescent;
    UINT          otmLineGap;
    UINT          otmsCapEmHeight;
    UINT          otmsXHeight;
    RECT          otmrcFontBox;
    INT           otmMacAscent;
    INT           otmMacDescent;
    UINT          otmMacLineGap;
    UINT          otmusMinimumPPEM;
    POINT         otmptSubscriptSize;
    POINT         otmptSubscriptOffset;
    POINT         otmptSuperscriptSize;
    POINT         otmptSuperscriptOffset;
    UINT          otmsStrikeoutSize;
    INT           otmsStrikeoutPosition;
    INT           otmsUnderscoreSize;
    INT           otmsUnderscorePosition;
    ULONG         otmpFamilyName;
    ULONG         otmpFaceName;
    ULONG         otmpStyleName;
    ULONG         otmpFullName;
} OUTLINETEXTMETRIC32;


static DWORD gdi_handle_type( HGDIOBJ obj )
{
    unsigned int handle = HandleToUlong( obj );
    return handle & NTGDI_HANDLE_TYPE_MASK;
}

NTSTATUS WINAPI wow64_NtGdiAbortDoc( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiAbortDoc( hdc );
}

NTSTATUS WINAPI wow64_NtGdiAbortPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiAbortPath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiAddFontMemResourceEx( UINT *args )
{
    void *ptr = get_ptr( &args );
    DWORD size = get_ulong( &args );
    void *dv = get_ptr( &args );
    ULONG dv_size = get_ulong( &args );
    DWORD *count = get_ptr( &args );

    return HandleToUlong( NtGdiAddFontMemResourceEx( ptr, size, dv, dv_size, count ));
}

NTSTATUS WINAPI wow64_NtGdiAddFontResourceW( UINT *args )
{
    const WCHAR *str = get_ptr( &args );
    ULONG size = get_ulong( &args );
    ULONG files = get_ulong( &args );
    DWORD flags = get_ulong( &args );
    DWORD tid = get_ulong( &args );
    void *dv = get_ptr( &args );

    return NtGdiAddFontResourceW( str, size, files, flags, tid, dv );
}

NTSTATUS WINAPI wow64_NtGdiAlphaBlend( UINT *args )
{
    HDC hdc_dst = get_handle( &args );
    int x_dst = get_ulong( &args );
    int y_dst = get_ulong( &args );
    int width_dst = get_ulong( &args );
    int height_dst = get_ulong( &args );
    HDC hdc_src = get_handle( &args );
    int x_src = get_ulong( &args );
    int y_src = get_ulong( &args );
    int width_src = get_ulong( &args );
    int height_src = get_ulong( &args );
    DWORD blend_function = get_ulong( &args );
    HANDLE xform = get_handle( &args );

    return NtGdiAlphaBlend( hdc_dst, x_dst, y_dst, width_dst, height_dst, hdc_src,
                            x_src, y_src, width_src, height_src, blend_function, xform );
}

NTSTATUS WINAPI wow64_NtGdiAngleArc( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    DWORD radius = get_ulong( &args );
    DWORD start_angle = get_ulong( &args );
    DWORD sweep_angle = get_ulong( &args );

    return NtGdiAngleArc( hdc, x, y, radius, start_angle, sweep_angle );
}

NTSTATUS WINAPI wow64_NtGdiArcInternal( UINT *args )
{
    UINT type = get_ulong( &args );
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );
    INT xstart = get_ulong( &args );
    INT ystart = get_ulong( &args );
    INT xend = get_ulong( &args );
    INT yend = get_ulong( &args );

    return NtGdiArcInternal( type, hdc, left, top, right, bottom, xstart, ystart, xend, yend );
}

NTSTATUS WINAPI wow64_NtGdiBeginPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiBeginPath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiBitBlt( UINT *args )
{
    HDC hdc_dst = get_handle( &args );
    INT x_dst = get_ulong( &args );
    INT y_dst = get_ulong( &args );
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );
    HDC hdc_src = get_handle( &args );
    INT x_src = get_ulong( &args );
    INT y_src = get_ulong( &args );
    DWORD rop = get_ulong( &args );
    DWORD bk_color = get_ulong( &args );
    FLONG fl = get_ulong( &args );

    return NtGdiBitBlt( hdc_dst, x_dst, y_dst, width, height, hdc_src,
                        x_src, y_src, rop, bk_color, fl );
}

NTSTATUS WINAPI wow64_NtGdiCloseFigure( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiCloseFigure( hdc );
}

NTSTATUS WINAPI wow64_NtGdiCombineRgn( UINT *args )
{
    HRGN dest = get_handle( &args );
    HRGN src1 = get_handle( &args );
    HRGN src2 = get_handle( &args );
    INT mode = get_ulong( &args );

    return NtGdiCombineRgn( dest, src1, src2, mode );
}

NTSTATUS WINAPI wow64_NtGdiComputeXformCoefficients( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiComputeXformCoefficients( hdc );
}

NTSTATUS WINAPI wow64_NtGdiCreateBitmap( UINT *args )
{
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );
    UINT planes = get_ulong( &args );
    UINT bpp = get_ulong( &args );
    const void *bits = get_ptr( &args );

    return HandleToUlong( NtGdiCreateBitmap( width, height, planes, bpp, bits ));
}

NTSTATUS WINAPI wow64_NtGdiCreateClientObj( UINT *args )
{
    ULONG type = get_ulong( &args );

    return HandleToUlong( NtGdiCreateClientObj( type ));
}

NTSTATUS WINAPI wow64_NtGdiCreateCompatibleBitmap( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );

    return HandleToUlong( NtGdiCreateCompatibleBitmap( hdc, width, height ));
}

NTSTATUS WINAPI wow64_NtGdiCreateCompatibleDC( UINT *args )
{
    HDC hdc = get_handle( &args );

    return HandleToUlong( NtGdiCreateCompatibleDC( hdc ));
}

NTSTATUS WINAPI wow64_NtGdiCreateDIBBrush( UINT *args )
{
    const void *data = get_ptr( &args );
    UINT coloruse = get_ulong( &args );
    UINT size = get_ulong( &args );
    BOOL is_8x8 = get_ulong( &args );
    BOOL pen = get_ulong( &args );
    const void *client = get_ptr( &args );

    return HandleToUlong( NtGdiCreateDIBBrush( data, coloruse, size, is_8x8, pen, client ));
}

NTSTATUS WINAPI wow64_NtGdiCreateDIBSection( UINT *args )
{
    HDC hdc = get_handle( &args );
    HANDLE section = get_handle( &args );
    DWORD offset = get_ulong( &args );
    const BITMAPINFO *bmi = get_ptr( &args );
    UINT usage = get_ulong( &args );
    UINT header_size = get_ulong( &args );
    ULONG flags = get_ulong( &args );
    ULONG_PTR color_space = get_ulong( &args );
    void *bits32 = get_ptr( &args );

    void *bits;
    HBITMAP ret;

    ret = NtGdiCreateDIBSection( hdc, section, offset, bmi, usage, header_size,
                                 flags, color_space, addr_32to64( &bits, bits32 ));
    put_addr( bits32, bits );
    return HandleToUlong( ret );
}

NTSTATUS WINAPI wow64_NtGdiCreateDIBitmapInternal( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );
    DWORD init = get_ulong( &args );
    const void *bits = get_ptr( &args );
    const BITMAPINFO *data = get_ptr( &args );
    UINT coloruse = get_ulong( &args );
    UINT max_info = get_ulong( &args );
    UINT max_bits = get_ulong( &args );
    ULONG flags = get_ulong( &args );
    HANDLE xform = get_handle( &args );

    HBITMAP ret = NtGdiCreateDIBitmapInternal( hdc, width, height, init, bits, data,
                                               coloruse, max_info, max_bits, flags, xform );
    return HandleToUlong( ret );
}

NTSTATUS WINAPI wow64_NtGdiCreateEllipticRgn( UINT *args )
{
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return HandleToUlong( NtGdiCreateEllipticRgn( left, top, right, bottom ));
}

NTSTATUS WINAPI wow64_NtGdiCreateHalftonePalette( UINT *args )
{
    HDC hdc = get_handle( &args );

    return HandleToUlong( NtGdiCreateHalftonePalette( hdc ));
}

NTSTATUS WINAPI wow64_NtGdiCreateHatchBrushInternal( UINT *args )
{
    INT style = get_ulong( &args );
    COLORREF color = get_ulong( &args );
    BOOL pen = get_ulong( &args );

    return HandleToULong( NtGdiCreateHatchBrushInternal( style, color, pen ));
}

NTSTATUS WINAPI wow64_NtGdiCreateMetafileDC( UINT *args )
{
    HDC hdc = get_handle( &args );

    return HandleToUlong( NtGdiCreateMetafileDC( hdc ));
}

NTSTATUS WINAPI wow64_NtGdiCreatePaletteInternal( UINT *args )
{
    const LOGPALETTE *palette = get_ptr( &args );
    UINT count = get_ulong( &args );

    return HandleToUlong( NtGdiCreatePaletteInternal( palette, count ));
}

NTSTATUS WINAPI wow64_NtGdiCreatePatternBrushInternal( UINT *args )
{
    HBITMAP hbitmap = get_handle( &args );
    BOOL pen = get_ulong( &args );
    BOOL is_8x8 = get_ulong( &args );

    return HandleToUlong( NtGdiCreatePatternBrushInternal( hbitmap, pen, is_8x8 ));
}

NTSTATUS WINAPI wow64_NtGdiCreatePen( UINT *args )
{
    INT style = get_ulong( &args );
    INT width = get_ulong( &args );
    COLORREF color = get_ulong( &args );
    HBRUSH brush = get_handle( &args );

    return HandleToUlong( NtGdiCreatePen( style, width, color, brush ));
}

NTSTATUS WINAPI wow64_NtGdiCreateRectRgn( UINT *args )
{
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return HandleToUlong( NtGdiCreateRectRgn( left, top, right, bottom ));
}

NTSTATUS WINAPI wow64_NtGdiCreateRoundRectRgn( UINT *args )
{
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );
    INT ellipse_width = get_ulong( &args );
    INT ellipse_height = get_ulong( &args );

    return HandleToUlong( NtGdiCreateRoundRectRgn( left, top, right, bottom,
                                                   ellipse_width, ellipse_height ));
}

NTSTATUS WINAPI wow64_NtGdiCreateSolidBrush( UINT *args )
{
    COLORREF color = get_ulong( &args );
    HBRUSH brush = get_handle( &args );

    return HandleToUlong( NtGdiCreateSolidBrush( color, brush ));
}

NTSTATUS WINAPI wow64_NtGdiDdDDICheckVidPnExclusiveOwnership( UINT *args )
{
    const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc = get_ptr( &args );

    return NtGdiDdDDICheckVidPnExclusiveOwnership( desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDICloseAdapter( UINT *args )
{
    const D3DKMT_CLOSEADAPTER *desc = get_ptr( &args );

    return NtGdiDdDDICloseAdapter( desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDICreateDCFromMemory( UINT *args )
{
    struct _D3DKMT_CREATEDCFROMMEMORY
    {
        ULONG pMemory;
        D3DDDIFORMAT Format;
        UINT Width;
        UINT Height;
        UINT Pitch;
        ULONG hDeviceDc;
        ULONG pColorTable;
        ULONG hDc;
        ULONG hBitmap;
    } *desc32 = get_ptr( &args );

    D3DKMT_CREATEDCFROMMEMORY desc;
    NTSTATUS status;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.pMemory = UlongToPtr( desc32->pMemory );
    desc.Format = desc32->Format;
    desc.Width = desc32->Width;
    desc.Height = desc32->Height;
    desc.Pitch = desc32->Pitch;
    desc.hDeviceDc = UlongToHandle( desc32->hDeviceDc );
    desc.pColorTable = UlongToPtr( desc32->pColorTable );

    if (!(status = NtGdiDdDDICreateDCFromMemory( &desc )))
    {
        desc32->hDc = HandleToUlong( desc.hDc );
        desc32->hBitmap = HandleToUlong( desc.hBitmap );
    }
    return status;
}

NTSTATUS WINAPI wow64_NtGdiDdDDICreateDevice( UINT *args )
{
    struct
    {
        D3DKMT_HANDLE hAdapter;
        D3DKMT_CREATEDEVICEFLAGS Flags;
        D3DKMT_HANDLE hDevice;
        ULONG pCommandBuffer;
        UINT CommandBufferSize;
        ULONG pAllocationList;
        UINT AllocationListSize;
        ULONG pPatchLocationList;
        UINT PatchLocationListSize;
    } *desc32 = get_ptr( &args );

    D3DKMT_CREATEDEVICE desc;
    NTSTATUS status;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.hAdapter = desc32->hAdapter;
    desc.Flags = desc32->Flags;
    desc.pCommandBuffer = UlongToPtr( desc32->pCommandBuffer );
    desc.CommandBufferSize = desc32->CommandBufferSize;
    desc.pAllocationList = UlongToPtr( desc32->pAllocationList );
    desc.AllocationListSize = desc32->AllocationListSize;
    desc.pPatchLocationList = UlongToPtr( desc32->pPatchLocationList );
    desc.PatchLocationListSize = desc32->PatchLocationListSize;
    if (!(status = NtGdiDdDDICreateDevice( &desc )))
        desc32->hDevice = desc.hDevice;
    return status;
}

NTSTATUS WINAPI wow64_NtGdiDdDDIDestroyDCFromMemory( UINT *args )
{
    const struct
    {
        ULONG hDc;
        ULONG hBitmap;
    } *desc32 = get_ptr( &args );
    D3DKMT_DESTROYDCFROMMEMORY desc;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.hDc = UlongToHandle( desc32->hDc );
    desc.hBitmap = UlongToHandle( desc32->hBitmap );

    return NtGdiDdDDIDestroyDCFromMemory( &desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDIDestroyDevice( UINT *args )
{
    const D3DKMT_DESTROYDEVICE *desc = get_ptr( &args );

    return NtGdiDdDDIDestroyDevice( desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDIEnumAdapters2( UINT *args )
{
    struct
    {
        ULONG NumAdapters;
        ULONG pAdapters;
    } *desc32 = get_ptr( &args );
    D3DKMT_ENUMADAPTERS2 desc;
    NTSTATUS status;

    if (!desc32) return STATUS_INVALID_PARAMETER;

    desc.NumAdapters = desc32->NumAdapters;
    desc.pAdapters = UlongToPtr( desc32->pAdapters );

    status = NtGdiDdDDIEnumAdapters2( &desc );

    desc32->NumAdapters = desc.NumAdapters;

    return status;
}

NTSTATUS WINAPI wow64_NtGdiDdDDIEscape( UINT *args )
{
    const struct
    {
        D3DKMT_HANDLE      hAdapter;
        D3DKMT_HANDLE      hDevice;
        D3DKMT_ESCAPETYPE  Type;
        D3DDDI_ESCAPEFLAGS Flags;
        ULONG              pPrivateDriverData;
        UINT               PrivateDriverDataSize;
        D3DKMT_HANDLE      hContext;
    } *desc32 = get_ptr( &args );
    D3DKMT_ESCAPE desc;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.hAdapter = desc32->hAdapter;
    desc.hDevice = desc32->hDevice;
    desc.Type = desc32->Type;
    desc.Flags = desc32->Flags;
    desc.pPrivateDriverData = UlongToPtr( desc32->pPrivateDriverData );
    desc.PrivateDriverDataSize = desc32->PrivateDriverDataSize;
    desc.hContext = desc32->hContext;

    return NtGdiDdDDIEscape( &desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromDeviceName( UINT *args )
{
    struct _D3DKMT_OPENADAPTERFROMDEVICENAME
    {
        ULONG pDeviceName;
        D3DKMT_HANDLE hAdapter;
        LUID AdapterLuid;
    } *desc32 = get_ptr( &args );
    D3DKMT_OPENADAPTERFROMDEVICENAME desc;
    NTSTATUS status;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.pDeviceName = UlongToPtr( desc32->pDeviceName );

    if (!(status = NtGdiDdDDIOpenAdapterFromDeviceName( &desc )))
    {
        desc32->hAdapter = desc.hAdapter;
        desc32->AdapterLuid = desc.AdapterLuid;
    }
    return status;
}

NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromHdc( UINT *args )
{
    struct
    {
        ULONG hDc;
        D3DKMT_HANDLE hAdapter;
        LUID AdapterLuid;
        D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
    } *desc32 = get_ptr( &args );

    D3DKMT_OPENADAPTERFROMHDC desc;
    NTSTATUS status;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.hDc = UlongToHandle( desc32->hDc );
    if (!(status = NtGdiDdDDIOpenAdapterFromHdc( &desc )))
    {
        desc32->hAdapter = desc.hAdapter;
        desc32->AdapterLuid = desc.AdapterLuid;
        desc32->VidPnSourceId = desc.VidPnSourceId;
    }
    return status;
}

NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromLuid( UINT *args )
{
    D3DKMT_OPENADAPTERFROMLUID *desc = get_ptr( &args );

    return NtGdiDdDDIOpenAdapterFromLuid( desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDIQueryAdapterInfo( UINT *args )
{
    struct _D3DKMT_QUERYADAPTERINFO
    {
        D3DKMT_HANDLE           hAdapter;
        KMTQUERYADAPTERINFOTYPE Type;
        ULONG                   pPrivateDriverData;
        UINT                    PrivateDriverDataSize;
    } *desc32 = get_ptr( &args );
    D3DKMT_QUERYADAPTERINFO desc;

    if (!desc32) return STATUS_INVALID_PARAMETER;

    desc.hAdapter = desc32->hAdapter;
    desc.Type = desc32->Type;
    desc.pPrivateDriverData = UlongToPtr( desc32->pPrivateDriverData );
    desc.PrivateDriverDataSize = desc32->PrivateDriverDataSize;

    return NtGdiDdDDIQueryAdapterInfo( &desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDIQueryStatistics( UINT *args )
{
    D3DKMT_QUERYSTATISTICS *stats = get_ptr( &args );

    return NtGdiDdDDIQueryStatistics( stats );
}

NTSTATUS WINAPI wow64_NtGdiDdDDIQueryVideoMemoryInfo( UINT *args )
{
    struct _D3DKMT_QUERYVIDEOMEMORYINFO
    {
        ULONG                       hProcess;
        D3DKMT_HANDLE               hAdapter;
        D3DKMT_MEMORY_SEGMENT_GROUP MemorySegmentGroup;
        UINT64                      Budget;
        UINT64                      CurrentUsage;
        UINT64                      CurrentReservation;
        UINT64                      AvailableForReservation;
        UINT                        PhysicalAdapterIndex;
    } *desc32 = get_ptr( &args );
    D3DKMT_QUERYVIDEOMEMORYINFO desc;
    NTSTATUS status;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.hProcess = LongToHandle( desc32->hProcess );
    desc.hAdapter = desc32->hAdapter;
    desc.MemorySegmentGroup = desc32->MemorySegmentGroup;
    desc.PhysicalAdapterIndex = desc32->PhysicalAdapterIndex;

    if (!(status = NtGdiDdDDIQueryVideoMemoryInfo( &desc )))
    {
        desc32->Budget = desc.Budget;
        desc32->CurrentUsage = desc.CurrentUsage;
        desc32->CurrentReservation = desc.CurrentReservation;
        desc32->AvailableForReservation = desc.AvailableForReservation;
    }
    return status;
}

NTSTATUS WINAPI wow64_NtGdiDdDDISetQueuedLimit( UINT *args )
{
    D3DKMT_SETQUEUEDLIMIT *desc = get_ptr( &args );

    return NtGdiDdDDISetQueuedLimit( desc );
}

NTSTATUS WINAPI wow64_NtGdiDdDDISetVidPnSourceOwner( UINT *args )
{
    const struct
    {
        D3DKMT_HANDLE hDevice;
        ULONG pType;
        ULONG pVidPnSourceId;
        UINT VidPnSourceCount;
    } *desc32 = get_ptr( &args );
    D3DKMT_SETVIDPNSOURCEOWNER desc;

    if (!desc32) return STATUS_INVALID_PARAMETER;
    desc.hDevice = desc32->hDevice;
    desc.pType = UlongToPtr( desc32->pType );
    desc.pVidPnSourceId = UlongToPtr( desc32->pVidPnSourceId );
    desc.VidPnSourceCount = desc32->VidPnSourceCount;

    return NtGdiDdDDISetVidPnSourceOwner( &desc );
}

NTSTATUS WINAPI wow64_NtGdiDeleteClientObj( UINT *args )
{
    HGDIOBJ obj = get_handle( &args );

    return NtGdiDeleteClientObj( obj );
}

NTSTATUS WINAPI wow64_NtGdiDeleteObjectApp( UINT *args )
{
    HGDIOBJ obj = get_handle( &args );

    return NtGdiDeleteObjectApp( obj );
}

NTSTATUS WINAPI wow64_NtGdiDescribePixelFormat( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT format = get_ulong( &args );
    UINT size = get_ulong( &args );
    PIXELFORMATDESCRIPTOR *descr = get_ptr( &args );

    return NtGdiDescribePixelFormat( hdc, format, size, descr );
}

NTSTATUS WINAPI wow64_NtGdiDoPalette( UINT *args )
{
    HGDIOBJ handle = get_handle( &args );
    WORD start = get_ulong( &args );
    WORD count = get_ulong( &args );
    void *entries = get_ptr( &args );
    DWORD func = get_ulong( &args );
    BOOL inbound = get_ulong( &args );

    return NtGdiDoPalette( handle, start, count, entries, func, inbound );
}

NTSTATUS WINAPI wow64_NtGdiDrawStream( UINT *args )
{
    HDC hdc = get_handle( &args );
    ULONG in = get_ulong( &args );
    void *pvin = get_ptr( &args );

    return NtGdiDrawStream( hdc, in, pvin );
}

NTSTATUS WINAPI wow64_NtGdiEllipse( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return NtGdiEllipse( hdc, left, top, right, bottom );
}

NTSTATUS WINAPI wow64_NtGdiEndDoc( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiEndDoc( hdc );
}

NTSTATUS WINAPI wow64_NtGdiEndPage( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiEndPage( hdc );
}

NTSTATUS WINAPI wow64_NtGdiEndPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiEndPath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiEnumFonts( UINT *args )
{
    HDC hdc = get_handle( &args );
    ULONG type = get_ulong( &args );
    ULONG win32_compat = get_ulong( &args );
    ULONG face_name_len = get_ulong( &args );
    const WCHAR *face_name = get_ptr( &args );
    ULONG charset = get_ulong( &args );
    ULONG *count = get_ptr( &args );
    void *buf = get_ptr( &args );

    return NtGdiEnumFonts( hdc, type, win32_compat, face_name_len, face_name, charset, count, buf );
}

NTSTATUS WINAPI wow64_NtGdiExcludeClipRect( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return NtGdiExcludeClipRect( hdc, left, top, right, bottom );
}

NTSTATUS WINAPI wow64_NtGdiEqualRgn( UINT *args )
{
    HRGN hrgn1 = get_handle( &args );
    HRGN hrgn2 = get_handle( &args );

    return NtGdiEqualRgn( hrgn1, hrgn2 );
}

NTSTATUS WINAPI wow64_NtGdiExtCreatePen( UINT *args )
{
    DWORD style = get_ulong( &args );
    DWORD width = get_ulong( &args );
    ULONG brush_style = get_ulong( &args );
    ULONG color = get_ulong( &args );
    ULONG_PTR client_hatch = get_ulong( &args );
    ULONG_PTR hatch = get_ulong( &args );
    DWORD style_count = get_ulong( &args );
    const DWORD *style_bits = get_ptr( &args );
    ULONG dib_size = get_ulong( &args );
    BOOL old_style = get_ulong( &args );
    HBRUSH brush = get_handle( &args );

    return HandleToUlong( NtGdiExtCreatePen( style, width, brush_style, color, client_hatch,
                                             hatch, style_count, style_bits, dib_size,
                                             old_style, brush ));
}

NTSTATUS WINAPI wow64_NtGdiExtCreateRegion( UINT *args )
{
    const XFORM *xform = get_ptr( &args );
    DWORD count = get_ulong( &args );
    const RGNDATA *data = get_ptr( &args );

    return HandleToUlong( NtGdiExtCreateRegion( xform, count, data ));
}

NTSTATUS WINAPI wow64_NtGdiExtEscape( UINT *args )
{
    HDC hdc = get_handle( &args );
    WCHAR *driver = get_ptr( &args );
    INT driver_id = get_ulong( &args );
    INT escape = get_ulong( &args );
    INT input_size = get_ulong( &args );
    const char *input = get_ptr( &args );
    INT output_size = get_ulong( &args );
    char *output = get_ptr( &args );

    return NtGdiExtEscape( hdc, driver, driver_id, escape, input_size, input, output_size, output );
}

NTSTATUS WINAPI wow64_NtGdiExtFloodFill( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    COLORREF color = get_ulong( &args );
    UINT type = get_ulong( &args );

    return NtGdiExtFloodFill( hdc, x, y, color, type );
}

NTSTATUS WINAPI wow64_NtGdiExtGetObjectW( UINT *args )
{
    HGDIOBJ handle = get_handle( &args );
    INT count = get_ulong( &args );
    void *buffer = get_ptr( &args );

    switch (gdi_handle_type( handle ))
    {
    case NTGDI_OBJ_BITMAP:
        {
            BITMAP32 *bitmap32 = buffer;
            struct
            {
                BITMAP32 dsBm;
                BITMAPINFOHEADER dsBmih;
                DWORD  dsBitfields[3];
                ULONG  dshSection;
                DWORD  dsOffset;
            } *dib32 = buffer;
            DIBSECTION dib;
            int ret;

            if (buffer)
            {
                if (count < sizeof(*bitmap32)) return 0;
                count = count < sizeof(*dib32) ? sizeof(BITMAP) : sizeof(DIBSECTION);
            }

            if (!(ret = NtGdiExtGetObjectW( handle, count, buffer ? &dib : NULL ))) return 0;

            if (bitmap32)
            {
                bitmap32->bmType = dib.dsBm.bmType;
                bitmap32->bmWidth = dib.dsBm.bmWidth;
                bitmap32->bmHeight = dib.dsBm.bmHeight;
                bitmap32->bmWidthBytes = dib.dsBm.bmWidthBytes;
                bitmap32->bmPlanes = dib.dsBm.bmPlanes;
                bitmap32->bmBitsPixel = dib.dsBm.bmBitsPixel;
                bitmap32->bmBits = PtrToUlong( dib.dsBm.bmBits );
            }
            if (ret != sizeof(dib)) return sizeof(*bitmap32);

            if (dib32)
            {
                dib32->dsBmih = dib.dsBmih;
                dib32->dsBitfields[0] = dib.dsBitfields[0];
                dib32->dsBitfields[1] = dib.dsBitfields[1];
                dib32->dsBitfields[2] = dib.dsBitfields[2];
                dib32->dshSection = HandleToUlong( dib.dshSection );
                dib32->dsOffset = dib.dsOffset;
            }
            return sizeof(*dib32);
        }

    case NTGDI_OBJ_PEN:
    case NTGDI_OBJ_EXTPEN:
        {
            EXTLOGPEN32 *pen32 = buffer;
            EXTLOGPEN *pen = NULL;

            if (count == sizeof(LOGPEN) || (buffer && !HIWORD( buffer )))
                return NtGdiExtGetObjectW( handle, count, buffer );

            if (pen32 && count && !(pen = Wow64AllocateTemp( count + sizeof(ULONG) ))) return 0;
            count = NtGdiExtGetObjectW( handle, count + sizeof(ULONG), pen );

            if (count == sizeof(LOGPEN))
            {
                if (buffer) memcpy( buffer, pen, count );
            }
            else if (count)
            {
                if (pen32)
                {
                    pen32->elpPenStyle = pen->elpPenStyle;
                    pen32->elpWidth = pen->elpWidth;
                    pen32->elpBrushStyle = pen->elpBrushStyle;
                    pen32->elpColor = pen->elpColor;
                    pen32->elpHatch = pen->elpHatch;
                    pen32->elpNumEntries = pen->elpNumEntries;
                }
                count -= FIELD_OFFSET( EXTLOGPEN, elpStyleEntry );
                if (count && pen32) memcpy( pen32->elpStyleEntry, pen->elpStyleEntry, count );
                count += FIELD_OFFSET( EXTLOGPEN32, elpStyleEntry );
            }
            return count;
        }

    default:
        return NtGdiExtGetObjectW( handle, count, buffer );
    }
}

NTSTATUS WINAPI wow64_NtGdiExtSelectClipRgn( UINT *args )
{
    HDC hdc = get_handle( &args );
    HRGN region = get_handle( &args );
    INT mode = get_ulong( &args );

    return NtGdiExtSelectClipRgn( hdc, region, mode );
}

NTSTATUS WINAPI wow64_NtGdiExtTextOutW( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    UINT flags = get_ulong( &args );
    const RECT *rect = get_ptr( &args );
    const WCHAR *str = get_ptr( &args );
    UINT count = get_ulong( &args );
    const INT *dx = get_ptr( &args );
    DWORD cp = get_ulong( &args );

    return NtGdiExtTextOutW( hdc, x, y, flags, rect, str, count, dx, cp );
}

NTSTATUS WINAPI wow64_NtGdiFillPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiFillPath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiFillRgn( UINT *args )
{
    HDC hdc = get_handle( &args );
    HRGN hrgn = get_handle( &args );
    HBRUSH hbrush = get_handle( &args );

    return NtGdiFillRgn( hdc, hrgn, hbrush );
}

NTSTATUS WINAPI wow64_NtGdiFlattenPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiFlattenPath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiFlush( UINT *args )
{
    return NtGdiFlush();
}

NTSTATUS WINAPI wow64_NtGdiFontIsLinked( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiFontIsLinked( hdc );
}

NTSTATUS WINAPI wow64_NtGdiFrameRgn( UINT *args )
{
    HDC hdc = get_handle( &args );
    HRGN hrgn = get_handle( &args );
    HBRUSH brush = get_handle( &args );
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );

    return NtGdiFrameRgn( hdc, hrgn, brush, width, height );
}

NTSTATUS WINAPI wow64_NtGdiGetAndSetDCDword( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT method = get_ulong( &args );
    DWORD value = get_ulong( &args );
    DWORD *result = get_ptr( &args );

    return NtGdiGetAndSetDCDword( hdc, method, value, result );
}

NTSTATUS WINAPI wow64_NtGdiGetAppClipBox( UINT *args )
{
    HDC hdc = get_handle( &args );
    RECT *rect = get_ptr( &args );

    return NtGdiGetAppClipBox( hdc, rect );
}

NTSTATUS WINAPI wow64_NtGdiGetBitmapBits( UINT *args )
{
    HBITMAP bitmap = get_handle( &args );
    LONG count = get_ulong( &args );
    void *bits = get_ptr( &args );

    return NtGdiGetBitmapBits( bitmap, count, bits );
}

NTSTATUS WINAPI wow64_NtGdiGetBitmapDimension( UINT *args )
{
    HBITMAP bitmap = get_handle( &args );
    SIZE *size = get_ptr( &args );

    return NtGdiGetBitmapDimension( bitmap, size );
}

NTSTATUS WINAPI wow64_NtGdiGetBoundsRect( UINT *args )
{
    HDC hdc = get_handle( &args );
    RECT *rect = get_ptr( &args );
    UINT flags = get_ulong( &args );

    return NtGdiGetBoundsRect( hdc, rect, flags );
}

NTSTATUS WINAPI wow64_NtGdiGetCharABCWidthsW( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT first = get_ulong( &args );
    UINT last = get_ulong( &args );
    WCHAR *chars = get_ptr( &args );
    ULONG flags = get_ulong( &args );
    void *buffer = get_ptr( &args );

    return NtGdiGetCharABCWidthsW( hdc, first, last, chars, flags, buffer );
}

NTSTATUS WINAPI wow64_NtGdiGetCharWidthW( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT first_char = get_ulong( &args );
    UINT last_char = get_ulong( &args );
    WCHAR *chars = get_ptr( &args );
    ULONG flags = get_ulong( &args );
    void *buffer = get_ptr( &args );

    return NtGdiGetCharWidthW( hdc, first_char, last_char, chars, flags, buffer );
}

NTSTATUS WINAPI wow64_NtGdiGetCharWidthInfo( UINT *args )
{
    HDC hdc = get_handle( &args );
    struct char_width_info *info = get_ptr( &args );

    return NtGdiGetCharWidthInfo( hdc, info );
}

NTSTATUS WINAPI wow64_NtGdiGetColorAdjustment( UINT *args )
{
    HDC hdc = get_handle( &args );
    COLORADJUSTMENT *ca = get_ptr( &args );

    return NtGdiGetColorAdjustment( hdc, ca );
}

NTSTATUS WINAPI wow64_NtGdiGetDCDword( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT method = get_ulong( &args );
    DWORD *result = get_ptr( &args );

    return NtGdiGetDCDword( hdc, method, result );
}

NTSTATUS WINAPI wow64_NtGdiGetDCObject( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT type = get_ulong( &args );

    return HandleToUlong( NtGdiGetDCObject( hdc, type ));
}

NTSTATUS WINAPI wow64_NtGdiGetDCPoint( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT method = get_ulong( &args );
    POINT *result = get_ptr( &args );

    return NtGdiGetDCPoint( hdc, method, result );
}

NTSTATUS WINAPI wow64_NtGdiGetDIBitsInternal( UINT *args )
{
    HDC hdc = get_handle( &args );
    HBITMAP hbitmap = get_handle( &args );
    UINT startscan = get_ulong( &args );
    UINT lines = get_ulong( &args );
    void *bits = get_ptr( &args );
    BITMAPINFO *info = get_ptr( &args );
    UINT coloruse = get_ulong( &args );
    UINT max_bits = get_ulong( &args );
    UINT max_info = get_ulong( &args );

    return NtGdiGetDIBitsInternal( hdc, hbitmap, startscan, lines, bits, info, coloruse,
                                   max_bits, max_info );
}

NTSTATUS WINAPI wow64_NtGdiGetDeviceCaps( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT cap = get_ulong( &args );

    return NtGdiGetDeviceCaps( hdc, cap );
}

NTSTATUS WINAPI wow64_NtGdiGetDeviceGammaRamp( UINT *args )
{
    HDC hdc = get_handle( &args );
    void *ptr = get_ptr( &args );

    return NtGdiGetDeviceGammaRamp( hdc, ptr );
}

NTSTATUS WINAPI wow64_NtGdiGetFontData( UINT *args )
{
    HDC hdc = get_handle( &args );
    DWORD table = get_ulong( &args );
    DWORD offset = get_ulong( &args );
    void *buffer = get_ptr( &args );
    DWORD length = get_ulong( &args );

    return NtGdiGetFontData( hdc, table, offset, buffer, length );
}

NTSTATUS WINAPI wow64_NtGdiGetFontFileData( UINT *args )
{
    DWORD instance_id = get_ulong( &args );
    DWORD file_index = get_ulong( &args );
    UINT64 *offset = get_ptr( &args );
    void *buff = get_ptr( &args );
    SIZE_T buff_size = get_ulong( &args );

    return NtGdiGetFontFileData( instance_id, file_index, offset, buff, buff_size );
}

NTSTATUS WINAPI wow64_NtGdiGetFontFileInfo( UINT *args )
{
    DWORD instance_id = get_ulong( &args );
    DWORD file_index = get_ulong( &args );
    struct font_fileinfo *info = get_ptr( &args );
    SIZE_T size = get_ulong( &args );
    ULONG *needed32 = get_ptr( &args );

    SIZE_T needed;
    BOOL ret;

    ret = NtGdiGetFontFileInfo( instance_id, file_index, info, size, size_32to64( &needed, needed32 ));
    put_size( needed32, needed );
    return ret;
}

NTSTATUS WINAPI wow64_NtGdiGetFontUnicodeRanges( UINT *args )
{
    HDC hdc = get_handle( &args );
    GLYPHSET *lpgs = get_ptr( &args );

    return NtGdiGetFontUnicodeRanges( hdc, lpgs );
}

NTSTATUS WINAPI wow64_NtGdiGetGlyphIndicesW( UINT *args )
{
    HDC hdc = get_handle( &args );
    const WCHAR *str = get_ptr( &args );
    INT count = get_ulong( &args );
    WORD *indices = get_ptr( &args );
    DWORD flags = get_ulong( &args );

    return NtGdiGetGlyphIndicesW( hdc, str, count, indices, flags );
}

NTSTATUS WINAPI wow64_NtGdiGetGlyphOutline( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT ch = get_ulong( &args );
    UINT format = get_ulong( &args );
    GLYPHMETRICS *metrics = get_ptr( &args );
    DWORD size = get_ulong( &args );
    void *buffer = get_ptr( &args );
    const MAT2 *mat2 = get_ptr( &args );
    BOOL ignore_rotation = get_ulong( &args );

    return NtGdiGetGlyphOutline( hdc, ch, format, metrics, size, buffer, mat2, ignore_rotation );
}

NTSTATUS WINAPI wow64_NtGdiGetKerningPairs( UINT *args )
{
    HDC hdc = get_handle( &args );
    DWORD count = get_ulong( &args );
    KERNINGPAIR *kern_pair = get_ptr( &args );

    return NtGdiGetKerningPairs( hdc, count, kern_pair );
}

NTSTATUS WINAPI wow64_NtGdiGetNearestColor( UINT *args )
{
    HDC hdc = get_handle( &args );
    COLORREF color = get_ulong( &args );

    return NtGdiGetNearestColor( hdc, color );
}

NTSTATUS WINAPI wow64_NtGdiGetNearestPaletteIndex( UINT *args )
{
    HPALETTE hpalette = get_handle( &args );
    COLORREF color = get_ulong( &args );

    return NtGdiGetNearestPaletteIndex( hpalette, color );
}

NTSTATUS WINAPI wow64_NtGdiGetOutlineTextMetricsInternalW( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT size = get_ulong( &args );
    OUTLINETEXTMETRIC32 *otm32 = get_ptr( &args );
    ULONG opts = get_ulong( &args );

    OUTLINETEXTMETRICW *otm, otm_buf;
    UINT ret, size64;
    static const size_t otm_size_diff = sizeof(*otm) - sizeof(*otm32);

    if (!otm32)
    {
        size64 = 0;
        otm = NULL;
    }
    else if (size <= sizeof(*otm32))
    {
        size64 = sizeof(otm_buf);
        otm = &otm_buf;
    }
    else
    {
        size64 = size + otm_size_diff;
        if (!(otm = Wow64AllocateTemp( size64 ))) return 0;
    }

    if (!(ret = NtGdiGetOutlineTextMetricsInternalW( hdc, size64, otm, opts ))) return 0;

    if (otm32)
    {
        OUTLINETEXTMETRIC32 out;

        memcpy( &out, otm, FIELD_OFFSET( OUTLINETEXTMETRIC32, otmpFamilyName ));
        if (out.otmSize >= sizeof(*otm)) out.otmSize -= otm_size_diff;

        if (!otm->otmpFamilyName) out.otmpFamilyName = 0;
        else out.otmpFamilyName = PtrToUlong( otm->otmpFamilyName ) - otm_size_diff;

        if (!otm->otmpFaceName) out.otmpFaceName = 0;
        else out.otmpFaceName = PtrToUlong( otm->otmpFaceName ) - otm_size_diff;

        if (!otm->otmpStyleName) out.otmpStyleName = 0;
        else out.otmpStyleName = PtrToUlong( otm->otmpStyleName ) - otm_size_diff;

        if (!otm->otmpFullName) out.otmpFullName = 0;
        else out.otmpFullName = PtrToUlong( otm->otmpFullName ) - otm_size_diff;

        memcpy( otm32, &out, min( size, sizeof(out) ));
        if (ret > sizeof(*otm)) memcpy( otm32 + 1, otm + 1, ret - sizeof(*otm) );
    }

    return ret >= sizeof(*otm) ? ret - otm_size_diff : ret;
}

NTSTATUS WINAPI wow64_NtGdiGetPath( UINT *args )
{
    HDC hdc = get_handle( &args );
    POINT *points = get_ptr( &args );
    BYTE *types = get_ptr( &args );
    INT size = get_ulong( &args );

    return NtGdiGetPath( hdc, points, types, size );
}

NTSTATUS WINAPI wow64_NtGdiGetPixel( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );

    return NtGdiGetPixel( hdc, x, y );
}

NTSTATUS WINAPI wow64_NtGdiGetRandomRgn( UINT *args )
{
    HDC hdc = get_handle( &args );
    HRGN region = get_handle( &args );
    INT code = get_ulong( &args );

    return NtGdiGetRandomRgn( hdc, region, code );
}

NTSTATUS WINAPI wow64_NtGdiGetRasterizerCaps( UINT *args )
{
    RASTERIZER_STATUS *status = get_ptr( &args );
    UINT size = get_ulong( &args );

    return NtGdiGetRasterizerCaps( status, size );
}

NTSTATUS WINAPI wow64_NtGdiGetRealizationInfo( UINT *args )
{
    HDC hdc = get_handle( &args );
    struct font_realization_info *info = get_ptr( &args );

    return NtGdiGetRealizationInfo( hdc, info );
}

NTSTATUS WINAPI wow64_NtGdiGetRegionData( UINT *args )
{
    HRGN hrgn = get_ptr( &args );
    DWORD count = get_ulong( &args );
    RGNDATA *data = get_ptr( &args );

    return NtGdiGetRegionData( hrgn, count, data );
}

NTSTATUS WINAPI wow64_NtGdiGetTextCharsetInfo( UINT *args )
{
    HDC hdc = get_ptr( &args );
    FONTSIGNATURE *fs = get_ptr( &args );
    DWORD flags = get_ulong( &args );

    return NtGdiGetTextCharsetInfo( hdc, fs, flags );
}

NTSTATUS WINAPI wow64_NtGdiGetTextExtentExW( UINT *args )
{
    HDC hdc = get_handle( &args );
    const WCHAR *str = get_ptr( &args );
    INT count = get_ulong( &args );
    INT max_ext = get_ulong( &args );
    INT *nfit = get_ptr( &args );
    INT *dxs = get_ptr( &args );
    SIZE *size = get_ptr( &args );
    UINT flags = get_ulong( &args );

    return NtGdiGetTextExtentExW( hdc, str, count, max_ext, nfit, dxs, size, flags );
}

NTSTATUS WINAPI wow64_NtGdiGetTextFaceW( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT count = get_ulong( &args );
    WCHAR *name = get_ptr( &args );
    BOOL alias_name = get_ulong( &args );

    return NtGdiGetTextFaceW( hdc, count, name, alias_name );
}

NTSTATUS WINAPI wow64_NtGdiGetTextMetricsW( UINT *args )
{
    HDC hdc = get_handle( &args );
    TEXTMETRICW *metrics = get_ptr( &args );
    ULONG flags = get_ulong( &args );

    return NtGdiGetTextMetricsW( hdc, metrics, flags );
}

NTSTATUS WINAPI wow64_NtGdiGradientFill( UINT *args )
{
    HDC hdc = get_handle( &args );
    TRIVERTEX *vert_array = get_ptr( &args );
    ULONG nvert = get_ulong( &args );
    void *grad_array = get_ptr( &args );
    ULONG ngrad = get_ulong( &args );
    ULONG mode = get_ulong( &args );

    return NtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
}

NTSTATUS WINAPI wow64_NtGdiIcmBrushInfo( UINT *args )
{
    HDC hdc = get_handle( &args );
    HBRUSH handle = get_handle( &args );
    BITMAPINFO *info = get_ptr( &args );
    void *bits = get_ptr( &args );
    ULONG *bits_size = get_ptr( &args );
    UINT *usage = get_ptr( &args );
    BOOL *unk = get_ptr( &args );
    UINT mode = get_ulong( &args );

    return NtGdiIcmBrushInfo( hdc, handle, info, bits, bits_size, usage, unk, mode );
}

NTSTATUS WINAPI wow64_NtGdiInvertRgn( UINT *args )
{
    HDC hdc = get_handle( &args );
    HRGN hrgn = get_handle( &args );

    return NtGdiInvertRgn( hdc, hrgn );
}

NTSTATUS WINAPI wow64_NtGdiLineTo( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );

    return NtGdiLineTo( hdc, x, y );
}

NTSTATUS WINAPI wow64_NtGdiMaskBlt( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x_dst = get_ulong( &args );
    INT y_dst = get_ulong( &args );
    INT width_dst = get_ulong( &args );
    INT height_dst = get_ulong( &args );
    HDC hdc_src = get_handle( &args );
    INT x_src = get_ulong( &args );
    INT y_src = get_ulong( &args );
    HBITMAP mask = get_handle( &args );
    INT x_mask = get_ulong( &args );
    INT y_mask = get_ulong( &args );
    DWORD rop = get_ulong( &args );
    DWORD bk_color = get_ulong( &args );

    return NtGdiMaskBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
                         x_src, y_src, mask, x_mask, y_mask, rop, bk_color );
}

NTSTATUS WINAPI wow64_NtGdiModifyWorldTransform( UINT *args )
{
    HDC hdc = get_handle( &args );
    const XFORM *xform = get_ptr( &args );
    DWORD mode = get_ulong( &args );

    return NtGdiModifyWorldTransform( hdc, xform, mode );
}

NTSTATUS WINAPI wow64_NtGdiMoveTo( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    POINT *pt = get_ptr( &args );

    return NtGdiMoveTo( hdc, x, y, pt );
}

NTSTATUS WINAPI wow64_NtGdiPolyDraw( UINT *args )
{
    HDC hdc = get_handle( &args );
    const POINT *points = get_ptr( &args );
    const BYTE *types = get_ptr( &args );
    DWORD count = get_ulong( &args );

    return NtGdiPolyDraw( hdc, points, types, count );
}

NTSTATUS WINAPI wow64_NtGdiPolyPolyDraw( UINT *args )
{
    HDC hdc = get_handle( &args );
    const POINT *points = get_ptr( &args );
    const ULONG *counts = get_ptr( &args );
    DWORD count = get_ulong( &args );
    UINT function = get_ulong( &args );

    return NtGdiPolyPolyDraw( hdc, points, counts, count, function );
}

NTSTATUS WINAPI wow64_NtGdiRectangle( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return NtGdiRectangle( hdc, left, top, right, bottom );
}

NTSTATUS WINAPI wow64_NtGdiResetDC( UINT *args )
{
    HDC hdc = get_handle( &args );
    const DEVMODEW *devmode = get_ptr( &args );
    BOOL *banding = get_ptr( &args );
    DRIVER_INFO_2W *driver_info = get_ptr( &args );
    void *dev = get_ptr( &args );

    return NtGdiResetDC( hdc, devmode, banding, driver_info, dev );
}

NTSTATUS WINAPI wow64_NtGdiResizePalette( UINT *args )
{
    HPALETTE palette = get_handle( &args );
    UINT count = get_ulong( &args );

    return NtGdiResizePalette( palette, count );
}

NTSTATUS WINAPI wow64_NtGdiRestoreDC( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT level = get_ulong( &args );

    return NtGdiRestoreDC( hdc, level );
}

NTSTATUS WINAPI wow64_NtGdiGetRgnBox( UINT *args )
{
    HRGN hrgn = get_handle( &args );
    RECT *rect = get_ptr( &args );

    return NtGdiGetRgnBox( hrgn, rect );
}

NTSTATUS WINAPI wow64_NtGdiRoundRect( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );
    INT ell_width = get_ulong( &args );
    INT ell_height = get_ulong( &args );

    return NtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
}

NTSTATUS WINAPI wow64_NtGdiGetSpoolMessage( UINT *args )
{
    void *ptr1 = get_ptr( &args );
    DWORD data2 = get_ulong( &args );
    void *ptr3 = get_ptr( &args );
    DWORD data4 = get_ulong( &args );

    return NtGdiGetSpoolMessage( ptr1, data2, ptr3, data4 );
}

NTSTATUS WINAPI wow64_NtGdiGetSystemPaletteUse( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiGetSystemPaletteUse( hdc );
}

NTSTATUS WINAPI wow64_NtGdiGetTransform( UINT *args )
{
    HDC hdc = get_handle( &args );
    DWORD which = get_ulong( &args );
    XFORM *xform = get_ptr( &args );

    return NtGdiGetTransform( hdc, which, xform );
}

NTSTATUS WINAPI wow64_NtGdiHfontCreate( UINT *args )
{
    const void *logfont = get_ptr( &args );
    ULONG unk2 = get_ulong( &args );
    ULONG unk3 = get_ulong( &args );
    ULONG unk4 = get_ulong( &args );
    void *data = get_ptr( &args );

    return HandleToUlong( NtGdiHfontCreate( logfont, unk2, unk3, unk4, data ));
}

NTSTATUS WINAPI wow64_NtGdiInitSpool( UINT *args )
{
    return NtGdiInitSpool();
}

NTSTATUS WINAPI wow64_NtGdiIntersectClipRect( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return NtGdiIntersectClipRect( hdc, left, top, right, bottom );
}

NTSTATUS WINAPI wow64_NtGdiOffsetClipRgn( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );

    return NtGdiOffsetClipRgn( hdc, x, y );
}

NTSTATUS WINAPI wow64_NtGdiOffsetRgn( UINT *args )
{
    HRGN hrgn = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );

    return NtGdiOffsetRgn( hrgn, x, y );
}

NTSTATUS WINAPI wow64_NtGdiOpenDCW( UINT *args )
{
    UNICODE_STRING32 *device32 = get_ptr( &args );
    const DEVMODEW *devmode = get_ptr( &args );
    UNICODE_STRING32 *output32 = get_ptr( &args );
    ULONG type = get_ulong( &args );
    BOOL is_display = get_ulong( &args );
    HANDLE hspool = get_handle( &args );
    DRIVER_INFO_2W *driver_info = get_ptr( &args );
    void *pdev = get_ptr( &args );

    UNICODE_STRING device, output;
    HDC ret = NtGdiOpenDCW( unicode_str_32to64( &device, device32 ), devmode,
                            unicode_str_32to64( &output, output32 ), type,
                            is_display, hspool, driver_info, pdev );
    return HandleToUlong( ret );
}

NTSTATUS WINAPI wow64_NtGdiPatBlt( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );
    DWORD rop = get_ulong( &args );

    return NtGdiPatBlt( hdc, left, top, width, height, rop );
}

NTSTATUS WINAPI wow64_NtGdiPathToRegion( UINT *args )
{
    HDC hdc = get_handle( &args );

    return HandleToUlong( NtGdiPathToRegion( hdc ));
}

NTSTATUS WINAPI wow64_NtGdiPlgBlt( UINT *args )
{
    HDC hdc = get_handle( &args );
    const POINT *point = get_ptr( &args );
    HDC hdc_src = get_handle( &args );
    INT x_src = get_ulong( &args );
    INT y_src = get_ulong( &args );
    INT width = get_ulong( &args );
    INT height = get_ulong( &args );
    HBITMAP mask = get_handle( &args );
    INT x_mask = get_ulong( &args );
    INT y_mask = get_ulong( &args );
    DWORD bk_color = get_ulong( &args );

    return NtGdiPlgBlt( hdc, point, hdc_src, x_src, y_src, width, height,
                        mask, x_mask, y_mask, bk_color );
}

NTSTATUS WINAPI wow64_NtGdiPtInRegion( UINT *args )
{
    HRGN hrgn = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );

    return NtGdiPtInRegion( hrgn, x, y );
}

NTSTATUS WINAPI wow64_NtGdiPtVisible( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );

    return NtGdiPtVisible( hdc, x, y );
}

NTSTATUS WINAPI wow64_NtGdiRectInRegion( UINT *args )
{
    HRGN hrgn = get_handle( &args );
    const RECT *rect = get_ptr( &args );

    return NtGdiRectInRegion( hrgn, rect );
}

NTSTATUS WINAPI wow64_NtGdiRectVisible( UINT *args )
{
    HDC hdc = get_handle( &args );
    const RECT *rect = get_ptr( &args );

    return NtGdiRectVisible( hdc, rect );
}

NTSTATUS WINAPI wow64_NtGdiRemoveFontMemResourceEx( UINT *args )
{
    HANDLE handle = get_handle( &args );

    return NtGdiRemoveFontMemResourceEx( handle );
}

NTSTATUS WINAPI wow64_NtGdiRemoveFontResourceW( UINT *args )
{
    const WCHAR *str = get_ptr( &args );
    ULONG size = get_ulong( &args );
    ULONG files = get_ulong( &args );
    DWORD flags = get_ulong( &args );
    DWORD tid = get_ulong( &args );
    void *dv = get_ptr( &args );

    return NtGdiRemoveFontResourceW( str, size, files, flags, tid, dv );
}

NTSTATUS WINAPI wow64_NtGdiSaveDC( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiSaveDC( hdc );
}

NTSTATUS WINAPI wow64_NtGdiScaleViewportExtEx( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x_num = get_ulong( &args );
    INT x_denom = get_ulong( &args );
    INT y_num = get_ulong( &args );
    INT y_denom = get_ulong( &args );
    SIZE *size = get_ptr( &args );

    return NtGdiScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
}

NTSTATUS WINAPI wow64_NtGdiScaleWindowExtEx( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x_num = get_ulong( &args );
    INT x_denom = get_ulong( &args );
    INT y_num = get_ulong( &args );
    INT y_denom = get_ulong( &args );
    SIZE *size = get_ptr( &args );

    return NtGdiScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
}

NTSTATUS WINAPI wow64_NtGdiSelectBitmap( UINT *args )
{
    HDC hdc = get_handle( &args );
    HGDIOBJ handle = get_handle( &args );

    return HandleToUlong( NtGdiSelectBitmap( hdc, handle ));
}

NTSTATUS WINAPI wow64_NtGdiSelectBrush( UINT *args )
{
    HDC hdc = get_handle( &args );
    HGDIOBJ handle = get_handle( &args );

    return HandleToUlong( NtGdiSelectBrush( hdc, handle ));
}

NTSTATUS WINAPI wow64_NtGdiSelectClipPath( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT mode = get_ulong( &args );

    return NtGdiSelectClipPath( hdc, mode );
}

NTSTATUS WINAPI wow64_NtGdiSelectFont( UINT *args )
{
    HDC hdc = get_handle( &args );
    HGDIOBJ handle = get_handle( &args );

    return HandleToUlong( NtGdiSelectFont( hdc, handle ));
}

NTSTATUS WINAPI wow64_NtGdiSelectPen( UINT *args )
{
    HDC hdc = get_handle( &args );
    HGDIOBJ handle = get_handle( &args );

    return HandleToUlong( NtGdiSelectPen( hdc, handle ));
}

NTSTATUS WINAPI wow64_NtGdiSetBitmapBits( UINT *args )
{
    HBITMAP hbitmap = get_handle( &args );
    LONG count = get_ulong( &args );
    const void *bits = get_ptr( &args );

    return NtGdiSetBitmapBits( hbitmap, count, bits );
}

NTSTATUS WINAPI wow64_NtGdiSetBitmapDimension( UINT *args )
{
    HBITMAP hbitmap = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    SIZE *prev_size = get_ptr( &args );

    return NtGdiSetBitmapDimension( hbitmap, x, y, prev_size );
}

NTSTATUS WINAPI wow64_NtGdiSetBoundsRect( UINT *args )
{
    HDC hdc = get_handle( &args );
    const RECT *rect = get_ptr( &args );
    UINT flags = get_ulong( &args );

    return NtGdiSetBoundsRect( hdc, rect, flags );
}

NTSTATUS WINAPI wow64_NtGdiSetBrushOrg( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    POINT *prev_org = get_ptr( &args );

    return NtGdiSetBrushOrg( hdc, x, y, prev_org );
}

NTSTATUS WINAPI wow64_NtGdiSetColorAdjustment( UINT *args )
{
    HDC hdc = get_handle( &args );
    const COLORADJUSTMENT *ca = get_ptr( &args );

    return NtGdiSetColorAdjustment( hdc, ca );
}

NTSTATUS WINAPI wow64_NtGdiSetDIBitsToDeviceInternal( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x_dst = get_ulong( &args );
    INT y_dst = get_ulong( &args );
    DWORD cx = get_ulong( &args );
    DWORD cy = get_ulong( &args );
    INT x_src = get_ulong( &args );
    INT y_src = get_ulong( &args );
    UINT startscan = get_ulong( &args );
    UINT lines = get_ulong( &args );
    const void *bits = get_ptr( &args );
    const BITMAPINFO *bmi = get_ptr( &args );
    UINT coloruse = get_ulong( &args );
    UINT max_bits = get_ulong( &args );
    UINT max_info = get_ulong( &args );
    BOOL xform_coords = get_ulong( &args );
    HANDLE xform = get_handle( &args );

    return NtGdiSetDIBitsToDeviceInternal( hdc, x_dst, y_dst, cx, cy, x_src, y_src,
                                           startscan, lines, bits, bmi, coloruse,
                                           max_bits, max_info, xform_coords, xform );
}

NTSTATUS WINAPI wow64_NtGdiSetDeviceGammaRamp( UINT *args )
{
    HDC hdc = get_handle( &args );
    void *ptr = get_ptr( &args );

    return NtGdiSetDeviceGammaRamp( hdc, ptr );
}

NTSTATUS WINAPI wow64_NtGdiSetLayout( UINT *args )
{
    HDC hdc = get_handle( &args );
    LONG wox = get_ulong( &args );
    DWORD layout = get_ulong( &args );

    return NtGdiSetLayout( hdc, wox, layout );
}

NTSTATUS WINAPI wow64_NtGdiSetMagicColors( UINT *args )
{
    HDC hdc = get_handle( &args );
    DWORD magic = get_ulong( &args );
    ULONG index = get_ulong( &args );

    return NtGdiSetMagicColors( hdc, magic, index );
}

NTSTATUS WINAPI wow64_NtGdiSetMetaRgn( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiSetMetaRgn( hdc );
}

NTSTATUS WINAPI wow64_NtGdiSetPixel( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x = get_ulong( &args );
    INT y = get_ulong( &args );
    COLORREF color = get_ulong( &args );

    return NtGdiSetPixel( hdc, x, y, color );
}

NTSTATUS WINAPI wow64_NtGdiSetPixelFormat( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT format = get_ulong( &args );

    return NtGdiSetPixelFormat( hdc, format );
}

NTSTATUS WINAPI wow64_NtGdiSetRectRgn( UINT *args )
{
    HRGN hrgn = get_handle( &args );
    INT left = get_ulong( &args );
    INT top = get_ulong( &args );
    INT right = get_ulong( &args );
    INT bottom = get_ulong( &args );

    return NtGdiSetRectRgn( hrgn, left, top, right, bottom );
}

NTSTATUS WINAPI wow64_NtGdiSetSystemPaletteUse( UINT *args )
{
    HDC hdc = get_handle( &args );
    UINT use = get_ulong( &args );

    return NtGdiSetSystemPaletteUse( hdc, use );
}

NTSTATUS WINAPI wow64_NtGdiSetTextJustification( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT extra = get_ulong( &args );
    INT breaks = get_ulong( &args );

    return NtGdiSetTextJustification( hdc, extra, breaks );
}

NTSTATUS WINAPI wow64_NtGdiSetVirtualResolution( UINT *args )
{
    HDC hdc = get_handle( &args );
    DWORD horz_res = get_ulong( &args );
    DWORD vert_res = get_ulong( &args );
    DWORD horz_size = get_ulong( &args );
    DWORD vert_size = get_ulong( &args );

    return NtGdiSetVirtualResolution( hdc, horz_res, vert_res, horz_size, vert_size );
}

NTSTATUS WINAPI wow64_NtGdiStartDoc( UINT *args )
{
    HDC hdc = get_handle( &args );
    const struct
    {
        INT   cbSize;
        ULONG lpszDocName;
        ULONG lpszOutput;
        ULONG lpszDatatype;
        DWORD fwType;
    } *doc32 = get_ptr( &args );
    BOOL *banding = get_ptr( &args );
    INT job = get_ulong( &args );

    DOCINFOW doc;
    doc.cbSize = sizeof(doc);
    doc.lpszDocName = UlongToPtr( doc32->lpszDocName );
    doc.lpszOutput = UlongToPtr( doc32->lpszOutput );
    doc.lpszDatatype = UlongToPtr( doc32->lpszDatatype );
    doc.fwType = doc32->fwType;

    return NtGdiStartDoc( hdc, &doc, banding, job );
}

NTSTATUS WINAPI wow64_NtGdiStartPage( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiStartPage( hdc );
}

NTSTATUS WINAPI wow64_NtGdiStretchBlt( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x_dst = get_ulong( &args );
    INT y_dst = get_ulong( &args );
    INT width_dst = get_ulong( &args );
    INT height_dst = get_ulong( &args );
    HDC hdc_src = get_handle( &args );
    INT x_src = get_ulong( &args );
    INT y_src = get_ulong( &args );
    INT width_src = get_ulong( &args );
    INT height_src = get_ulong( &args );
    DWORD rop = get_ulong( &args );
    COLORREF bk_color = get_ulong( &args );

    return NtGdiStretchBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
                            x_src, y_src, width_src, height_src, rop, bk_color );
}

NTSTATUS WINAPI wow64_NtGdiStretchDIBitsInternal( UINT *args )
{
    HDC hdc = get_handle( &args );
    INT x_dst = get_ulong( &args );
    INT y_dst = get_ulong( &args );
    INT width_dst = get_ulong( &args );
    INT height_dst = get_ulong( &args );
    INT x_src = get_ulong( &args );
    INT y_src = get_ulong( &args );
    INT width_src = get_ulong( &args );
    INT height_src = get_ulong( &args );
    const void *bits = get_ptr( &args );
    const BITMAPINFO *bmi = get_ptr( &args );
    UINT coloruse = get_ulong( &args );
    DWORD rop = get_ulong( &args );
    UINT max_info = get_ulong( &args );
    UINT max_bits = get_ulong( &args );
    HANDLE xform = get_handle( &args );

    return NtGdiStretchDIBitsInternal( hdc, x_dst, y_dst, width_dst, height_dst,
                                       x_src, y_src, width_src, height_src, bits, bmi,
                                       coloruse, rop, max_info, max_bits, xform );
}

NTSTATUS WINAPI wow64_NtGdiStrokeAndFillPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiStrokeAndFillPath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiStrokePath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiStrokePath( hdc );
}

NTSTATUS WINAPI wow64_NtGdiSwapBuffers( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiSwapBuffers( hdc );
}

NTSTATUS WINAPI wow64_NtGdiTransparentBlt( UINT *args )
{
    HDC hdc = get_handle( &args );
    int x_dst = get_ulong( &args );
    int y_dst = get_ulong( &args );
    int width_dst = get_ulong( &args );
    int height_dst = get_ulong( &args );
    HDC hdc_src = get_handle( &args );
    int x_src = get_ulong( &args );
    int y_src = get_ulong( &args );
    int width_src = get_ulong( &args );
    int height_src = get_ulong( &args );
    UINT color = get_ulong( &args );

    return NtGdiTransparentBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
                                x_src, y_src, width_src, height_src, color );
}

NTSTATUS WINAPI wow64_NtGdiTransformPoints( UINT *args )
{
    HDC hdc = get_handle( &args );
    const POINT *points_in = get_ptr( &args );
    POINT *points_out = get_ptr( &args );
    INT count = get_ulong( &args );
    UINT mode = get_ulong( &args );

    return NtGdiTransformPoints( hdc, points_in, points_out, count, mode );
}

NTSTATUS WINAPI wow64_NtGdiUnrealizeObject( UINT *args )
{
    HGDIOBJ obj = get_handle( &args );

    return NtGdiUnrealizeObject( obj );
}

NTSTATUS WINAPI wow64_NtGdiUpdateColors( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiUpdateColors( hdc );
}

NTSTATUS WINAPI wow64_NtGdiWidenPath( UINT *args )
{
    HDC hdc = get_handle( &args );

    return NtGdiWidenPath( hdc );
}

NTSTATUS WINAPI wow64___wine_get_icm_profile( UINT *args )
{
    HDC hdc = get_handle( &args );
    BOOL allow_default = get_ulong( &args );
    DWORD *size = get_ptr( &args );
    WCHAR *filename = get_ptr( &args );

    return __wine_get_icm_profile( hdc, allow_default, size, filename );
}

NTSTATUS WINAPI wow64___wine_get_file_outline_text_metric( UINT *args )
{
    const WCHAR *path = get_ptr( &args );
    TEXTMETRICW *otm = get_ptr( &args );
    UINT *em_square = get_ptr( &args );
    WCHAR *face_name = get_ptr( &args );

    return __wine_get_file_outline_text_metric( path, otm, em_square, face_name );
}