FD_DEVICEMETRICS

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct POINTE
{
    public float x;
    public float y;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct POINTL
{
    public int x;
    public int y;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FD_XFORM
{
    public float eXX;
    public float eXY;
    public float eYX;
    public float eYY;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FD_DEVICEMETRICS
{
    public uint flRealizedType;
    public POINTE pteBase;
    public POINTE pteSide;
    public int lD;
    public int fxMaxAscender;
    public int fxMaxDescender;
    public POINTL ptlUnderline1;
    public POINTL ptlStrikeOut;
    public POINTL ptlULThickness;
    public POINTL ptlSOThickness;
    public uint cxMax;
    public uint cyMax;
    public uint cjGlyphMax;
    public FD_XFORM fdxQuantized;
    public int lNonLinearExtLeading;
    public int lNonLinearIntLeading;
    public int lNonLinearMaxCharWidth;
    public int lNonLinearAvgCharWidth;
    public int lMinA;
    public int lMinC;
    public int lMinD;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public int[] alReserved;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure POINTE
    Public x As Single
    Public y As Single
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure POINTL
    Public x As Integer
    Public y As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FD_XFORM
    Public eXX As Single
    Public eXY As Single
    Public eYX As Single
    Public eYY As Single
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FD_DEVICEMETRICS
    Public flRealizedType As UInteger
    Public pteBase As POINTE
    Public pteSide As POINTE
    Public lD As Integer
    Public fxMaxAscender As Integer
    Public fxMaxDescender As Integer
    Public ptlUnderline1 As POINTL
    Public ptlStrikeOut As POINTL
    Public ptlULThickness As POINTL
    Public ptlSOThickness As POINTL
    Public cxMax As UInteger
    Public cyMax As UInteger
    Public cjGlyphMax As UInteger
    Public fdxQuantized As FD_XFORM
    Public lNonLinearExtLeading As Integer
    Public lNonLinearIntLeading As Integer
    Public lNonLinearMaxCharWidth As Integer
    Public lNonLinearAvgCharWidth As Integer
    Public lMinA As Integer
    Public lMinC As Integer
    Public lMinD As Integer
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public alReserved() As Integer
End Structure

import ctypes
from ctypes import wintypes

class POINTE(ctypes.Structure):
    _fields_ = [
        ("x", ctypes.c_float),
        ("y", ctypes.c_float),
    ]

class POINTL(ctypes.Structure):
    _fields_ = [
        ("x", ctypes.c_int),
        ("y", ctypes.c_int),
    ]

class FD_XFORM(ctypes.Structure):
    _fields_ = [
        ("eXX", ctypes.c_float),
        ("eXY", ctypes.c_float),
        ("eYX", ctypes.c_float),
        ("eYY", ctypes.c_float),
    ]

class FD_DEVICEMETRICS(ctypes.Structure):
    _fields_ = [
        ("flRealizedType", wintypes.DWORD),
        ("pteBase", POINTE),
        ("pteSide", POINTE),
        ("lD", ctypes.c_int),
        ("fxMaxAscender", ctypes.c_int),
        ("fxMaxDescender", ctypes.c_int),
        ("ptlUnderline1", POINTL),
        ("ptlStrikeOut", POINTL),
        ("ptlULThickness", POINTL),
        ("ptlSOThickness", POINTL),
        ("cxMax", wintypes.DWORD),
        ("cyMax", wintypes.DWORD),
        ("cjGlyphMax", wintypes.DWORD),
        ("fdxQuantized", FD_XFORM),
        ("lNonLinearExtLeading", ctypes.c_int),
        ("lNonLinearIntLeading", ctypes.c_int),
        ("lNonLinearMaxCharWidth", ctypes.c_int),
        ("lNonLinearAvgCharWidth", ctypes.c_int),
        ("lMinA", ctypes.c_int),
        ("lMinC", ctypes.c_int),
        ("lMinD", ctypes.c_int),
        ("alReserved", ctypes.c_int * 1),
    ]

#[repr(C)]
pub struct POINTE {
    pub x: f32,
    pub y: f32,
}

#[repr(C)]
pub struct POINTL {
    pub x: i32,
    pub y: i32,
}

#[repr(C)]
pub struct FD_XFORM {
    pub eXX: f32,
    pub eXY: f32,
    pub eYX: f32,
    pub eYY: f32,
}

#[repr(C)]
pub struct FD_DEVICEMETRICS {
    pub flRealizedType: u32,
    pub pteBase: POINTE,
    pub pteSide: POINTE,
    pub lD: i32,
    pub fxMaxAscender: i32,
    pub fxMaxDescender: i32,
    pub ptlUnderline1: POINTL,
    pub ptlStrikeOut: POINTL,
    pub ptlULThickness: POINTL,
    pub ptlSOThickness: POINTL,
    pub cxMax: u32,
    pub cyMax: u32,
    pub cjGlyphMax: u32,
    pub fdxQuantized: FD_XFORM,
    pub lNonLinearExtLeading: i32,
    pub lNonLinearIntLeading: i32,
    pub lNonLinearMaxCharWidth: i32,
    pub lNonLinearAvgCharWidth: i32,
    pub lMinA: i32,
    pub lMinC: i32,
    pub lMinD: i32,
    pub alReserved: [i32; 1],
}

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

type POINTE struct {
	x float32
	y float32
}

type POINTL struct {
	x int32
	y int32
}

type FD_XFORM struct {
	eXX float32
	eXY float32
	eYX float32
	eYY float32
}

type FD_DEVICEMETRICS struct {
	flRealizedType uint32
	pteBase POINTE
	pteSide POINTE
	lD int32
	fxMaxAscender int32
	fxMaxDescender int32
	ptlUnderline1 POINTL
	ptlStrikeOut POINTL
	ptlULThickness POINTL
	ptlSOThickness POINTL
	cxMax uint32
	cyMax uint32
	cjGlyphMax uint32
	fdxQuantized FD_XFORM
	lNonLinearExtLeading int32
	lNonLinearIntLeading int32
	lNonLinearMaxCharWidth int32
	lNonLinearAvgCharWidth int32
	lMinA int32
	lMinC int32
	lMinD int32
	alReserved [1]int32
}

type
  POINTE = record
    x: Single;
    y: Single;
  end;

  POINTL = record
    x: Integer;
    y: Integer;
  end;

  FD_XFORM = record
    eXX: Single;
    eXY: Single;
    eYX: Single;
    eYY: Single;
  end;

  FD_DEVICEMETRICS = record
    flRealizedType: DWORD;
    pteBase: POINTE;
    pteSide: POINTE;
    lD: Integer;
    fxMaxAscender: Integer;
    fxMaxDescender: Integer;
    ptlUnderline1: POINTL;
    ptlStrikeOut: POINTL;
    ptlULThickness: POINTL;
    ptlSOThickness: POINTL;
    cxMax: DWORD;
    cyMax: DWORD;
    cjGlyphMax: DWORD;
    fdxQuantized: FD_XFORM;
    lNonLinearExtLeading: Integer;
    lNonLinearIntLeading: Integer;
    lNonLinearMaxCharWidth: Integer;
    lNonLinearAvgCharWidth: Integer;
    lMinA: Integer;
    lMinC: Integer;
    lMinD: Integer;
    alReserved: array[0..0] of Integer;
  end;

const POINTE = extern struct {
    x: f32,
    y: f32,
};

const POINTL = extern struct {
    x: i32,
    y: i32,
};

const FD_XFORM = extern struct {
    eXX: f32,
    eXY: f32,
    eYX: f32,
    eYY: f32,
};

const FD_DEVICEMETRICS = extern struct {
    flRealizedType: u32,
    pteBase: POINTE,
    pteSide: POINTE,
    lD: i32,
    fxMaxAscender: i32,
    fxMaxDescender: i32,
    ptlUnderline1: POINTL,
    ptlStrikeOut: POINTL,
    ptlULThickness: POINTL,
    ptlSOThickness: POINTL,
    cxMax: u32,
    cyMax: u32,
    cjGlyphMax: u32,
    fdxQuantized: FD_XFORM,
    lNonLinearExtLeading: i32,
    lNonLinearIntLeading: i32,
    lNonLinearMaxCharWidth: i32,
    lNonLinearAvgCharWidth: i32,
    lMinA: i32,
    lMinC: i32,
    lMinD: i32,
    alReserved: [1]i32,
};

type
  POINTE {.bycopy.} = object
    x: float32
    y: float32

  POINTL {.bycopy.} = object
    x: int32
    y: int32

  FD_XFORM {.bycopy.} = object
    eXX: float32
    eXY: float32
    eYX: float32
    eYY: float32

  FD_DEVICEMETRICS {.bycopy.} = object
    flRealizedType: uint32
    pteBase: POINTE
    pteSide: POINTE
    lD: int32
    fxMaxAscender: int32
    fxMaxDescender: int32
    ptlUnderline1: POINTL
    ptlStrikeOut: POINTL
    ptlULThickness: POINTL
    ptlSOThickness: POINTL
    cxMax: uint32
    cyMax: uint32
    cjGlyphMax: uint32
    fdxQuantized: FD_XFORM
    lNonLinearExtLeading: int32
    lNonLinearIntLeading: int32
    lNonLinearMaxCharWidth: int32
    lNonLinearAvgCharWidth: int32
    lMinA: int32
    lMinC: int32
    lMinD: int32
    alReserved: array[1, int32]

struct POINTE
{
    float x;
    float y;
}

struct POINTL
{
    int x;
    int y;
}

struct FD_XFORM
{
    float eXX;
    float eXY;
    float eYX;
    float eYY;
}

struct FD_DEVICEMETRICS
{
    uint flRealizedType;
    POINTE pteBase;
    POINTE pteSide;
    int lD;
    int fxMaxAscender;
    int fxMaxDescender;
    POINTL ptlUnderline1;
    POINTL ptlStrikeOut;
    POINTL ptlULThickness;
    POINTL ptlSOThickness;
    uint cxMax;
    uint cyMax;
    uint cjGlyphMax;
    FD_XFORM fdxQuantized;
    int lNonLinearExtLeading;
    int lNonLinearIntLeading;
    int lNonLinearMaxCharWidth;
    int lNonLinearAvgCharWidth;
    int lMinA;
    int lMinC;
    int lMinD;
    int[1] alReserved;
}