ENHMETAHEADER3

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RECTL
{
    public int left;
    public int top;
    public int right;
    public int bottom;
}

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ENHMETAHEADER3
{
    public uint iType;
    public uint nSize;
    public RECTL rclBounds;
    public RECTL rclFrame;
    public uint dSignature;
    public uint nVersion;
    public uint nBytes;
    public uint nRecords;
    public ushort nHandles;
    public ushort sReserved;
    public uint nDescription;
    public uint offDescription;
    public uint nPalEntries;
    public SIZE szlDevice;
    public SIZE szlMillimeters;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECTL
    Public left As Integer
    Public top As Integer
    Public right As Integer
    Public bottom As Integer
End Structure

<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 ENHMETAHEADER3
    Public iType As UInteger
    Public nSize As UInteger
    Public rclBounds As RECTL
    Public rclFrame As RECTL
    Public dSignature As UInteger
    Public nVersion As UInteger
    Public nBytes As UInteger
    Public nRecords As UInteger
    Public nHandles As UShort
    Public sReserved As UShort
    Public nDescription As UInteger
    Public offDescription As UInteger
    Public nPalEntries As UInteger
    Public szlDevice As SIZE
    Public szlMillimeters As SIZE
End Structure

import ctypes
from ctypes import wintypes

class RECTL(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_int),
        ("top", ctypes.c_int),
        ("right", ctypes.c_int),
        ("bottom", ctypes.c_int),
    ]

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

class ENHMETAHEADER3(ctypes.Structure):
    _fields_ = [
        ("iType", wintypes.DWORD),
        ("nSize", wintypes.DWORD),
        ("rclBounds", RECTL),
        ("rclFrame", RECTL),
        ("dSignature", wintypes.DWORD),
        ("nVersion", wintypes.DWORD),
        ("nBytes", wintypes.DWORD),
        ("nRecords", wintypes.DWORD),
        ("nHandles", ctypes.c_ushort),
        ("sReserved", ctypes.c_ushort),
        ("nDescription", wintypes.DWORD),
        ("offDescription", wintypes.DWORD),
        ("nPalEntries", wintypes.DWORD),
        ("szlDevice", SIZE),
        ("szlMillimeters", SIZE),
    ]

#[repr(C)]
pub struct RECTL {
    pub left: i32,
    pub top: i32,
    pub right: i32,
    pub bottom: i32,
}

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

#[repr(C)]
pub struct ENHMETAHEADER3 {
    pub iType: u32,
    pub nSize: u32,
    pub rclBounds: RECTL,
    pub rclFrame: RECTL,
    pub dSignature: u32,
    pub nVersion: u32,
    pub nBytes: u32,
    pub nRecords: u32,
    pub nHandles: u16,
    pub sReserved: u16,
    pub nDescription: u32,
    pub offDescription: u32,
    pub nPalEntries: u32,
    pub szlDevice: SIZE,
    pub szlMillimeters: SIZE,
}

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

type RECTL struct {
	left int32
	top int32
	right int32
	bottom int32
}

type SIZE struct {
	cx int32
	cy int32
}

type ENHMETAHEADER3 struct {
	iType uint32
	nSize uint32
	rclBounds RECTL
	rclFrame RECTL
	dSignature uint32
	nVersion uint32
	nBytes uint32
	nRecords uint32
	nHandles uint16
	sReserved uint16
	nDescription uint32
	offDescription uint32
	nPalEntries uint32
	szlDevice SIZE
	szlMillimeters SIZE
}

type
  RECTL = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

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

  ENHMETAHEADER3 = record
    iType: DWORD;
    nSize: DWORD;
    rclBounds: RECTL;
    rclFrame: RECTL;
    dSignature: DWORD;
    nVersion: DWORD;
    nBytes: DWORD;
    nRecords: DWORD;
    nHandles: Word;
    sReserved: Word;
    nDescription: DWORD;
    offDescription: DWORD;
    nPalEntries: DWORD;
    szlDevice: SIZE;
    szlMillimeters: SIZE;
  end;

const RECTL = extern struct {
    left: i32,
    top: i32,
    right: i32,
    bottom: i32,
};

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

const ENHMETAHEADER3 = extern struct {
    iType: u32,
    nSize: u32,
    rclBounds: RECTL,
    rclFrame: RECTL,
    dSignature: u32,
    nVersion: u32,
    nBytes: u32,
    nRecords: u32,
    nHandles: u16,
    sReserved: u16,
    nDescription: u32,
    offDescription: u32,
    nPalEntries: u32,
    szlDevice: SIZE,
    szlMillimeters: SIZE,
};

type
  RECTL {.bycopy.} = object
    left: int32
    top: int32
    right: int32
    bottom: int32

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

  ENHMETAHEADER3 {.bycopy.} = object
    iType: uint32
    nSize: uint32
    rclBounds: RECTL
    rclFrame: RECTL
    dSignature: uint32
    nVersion: uint32
    nBytes: uint32
    nRecords: uint32
    nHandles: uint16
    sReserved: uint16
    nDescription: uint32
    offDescription: uint32
    nPalEntries: uint32
    szlDevice: SIZE
    szlMillimeters: SIZE

struct RECTL
{
    int left;
    int top;
    int right;
    int bottom;
}

struct SIZE
{
    int cx;
    int cy;
}

struct ENHMETAHEADER3
{
    uint iType;
    uint nSize;
    RECTL rclBounds;
    RECTL rclFrame;
    uint dSignature;
    uint nVersion;
    uint nBytes;
    uint nRecords;
    ushort nHandles;
    ushort sReserved;
    uint nDescription;
    uint offDescription;
    uint nPalEntries;
    SIZE szlDevice;
    SIZE szlMillimeters;
}