FONTOBJ

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SIZE
{
    public int cx;
    public int cy;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FONTOBJ
{
    public uint iUniq;
    public uint iFace;
    public uint cxMax;
    public uint flFontType;
    public UIntPtr iTTUniq;
    public UIntPtr iFile;
    public SIZE sizLogResPpi;
    public uint ulStyleSize;
    public IntPtr pvConsumer;
    public IntPtr pvProducer;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SIZE
    Public cx As Integer
    Public cy As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FONTOBJ
    Public iUniq As UInteger
    Public iFace As UInteger
    Public cxMax As UInteger
    Public flFontType As UInteger
    Public iTTUniq As UIntPtr
    Public iFile As UIntPtr
    Public sizLogResPpi As SIZE
    Public ulStyleSize As UInteger
    Public pvConsumer As IntPtr
    Public pvProducer As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class SIZE(ctypes.Structure):
    _fields_ = [
        ("cx", ctypes.c_int),
        ("cy", ctypes.c_int),
    ]

class FONTOBJ(ctypes.Structure):
    _fields_ = [
        ("iUniq", wintypes.DWORD),
        ("iFace", wintypes.DWORD),
        ("cxMax", wintypes.DWORD),
        ("flFontType", wintypes.DWORD),
        ("iTTUniq", ctypes.c_size_t),
        ("iFile", ctypes.c_size_t),
        ("sizLogResPpi", SIZE),
        ("ulStyleSize", wintypes.DWORD),
        ("pvConsumer", ctypes.c_void_p),
        ("pvProducer", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct SIZE {
    pub cx: i32,
    pub cy: i32,
}

#[repr(C)]
pub struct FONTOBJ {
    pub iUniq: u32,
    pub iFace: u32,
    pub cxMax: u32,
    pub flFontType: u32,
    pub iTTUniq: usize,
    pub iFile: usize,
    pub sizLogResPpi: SIZE,
    pub ulStyleSize: u32,
    pub pvConsumer: *mut core::ffi::c_void,
    pub pvProducer: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type SIZE struct {
	cx int32
	cy int32
}

type FONTOBJ struct {
	iUniq uint32
	iFace uint32
	cxMax uint32
	flFontType uint32
	iTTUniq uintptr
	iFile uintptr
	sizLogResPpi SIZE
	ulStyleSize uint32
	pvConsumer uintptr
	pvProducer uintptr
}

type
  SIZE = record
    cx: Integer;
    cy: Integer;
  end;

  FONTOBJ = record
    iUniq: DWORD;
    iFace: DWORD;
    cxMax: DWORD;
    flFontType: DWORD;
    iTTUniq: NativeUInt;
    iFile: NativeUInt;
    sizLogResPpi: SIZE;
    ulStyleSize: DWORD;
    pvConsumer: Pointer;
    pvProducer: Pointer;
  end;

const SIZE = extern struct {
    cx: i32,
    cy: i32,
};

const FONTOBJ = extern struct {
    iUniq: u32,
    iFace: u32,
    cxMax: u32,
    flFontType: u32,
    iTTUniq: usize,
    iFile: usize,
    sizLogResPpi: SIZE,
    ulStyleSize: u32,
    pvConsumer: ?*anyopaque,
    pvProducer: ?*anyopaque,
};

type
  SIZE {.bycopy.} = object
    cx: int32
    cy: int32

  FONTOBJ {.bycopy.} = object
    iUniq: uint32
    iFace: uint32
    cxMax: uint32
    flFontType: uint32
    iTTUniq: uint
    iFile: uint
    sizLogResPpi: SIZE
    ulStyleSize: uint32
    pvConsumer: pointer
    pvProducer: pointer

struct SIZE
{
    int cx;
    int cy;
}

struct FONTOBJ
{
    uint iUniq;
    uint iFace;
    uint cxMax;
    uint flFontType;
    size_t iTTUniq;
    size_t iFile;
    SIZE sizLogResPpi;
    uint ulStyleSize;
    void* pvConsumer;
    void* pvProducer;
}