PRINTDLGEXA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct PRINTDLGEXA
{
    public uint lStructSize;
    public IntPtr hwndOwner;
    public IntPtr hDevMode;
    public IntPtr hDevNames;
    public IntPtr hDC;
    public uint Flags;
    public uint Flags2;
    public uint ExclusionFlags;
    public uint nPageRanges;
    public uint nMaxPageRanges;
    public IntPtr lpPageRanges;
    public uint nMinPage;
    public uint nMaxPage;
    public uint nCopies;
    public IntPtr hInstance;
    public IntPtr lpPrintTemplateName;
    public IntPtr lpCallback;
    public uint nPropertyPages;
    public IntPtr lphPropertyPages;
    public uint nStartPage;
    public uint dwResultAction;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure PRINTDLGEXA
    Public lStructSize As UInteger
    Public hwndOwner As IntPtr
    Public hDevMode As IntPtr
    Public hDevNames As IntPtr
    Public hDC As IntPtr
    Public Flags As UInteger
    Public Flags2 As UInteger
    Public ExclusionFlags As UInteger
    Public nPageRanges As UInteger
    Public nMaxPageRanges As UInteger
    Public lpPageRanges As IntPtr
    Public nMinPage As UInteger
    Public nMaxPage As UInteger
    Public nCopies As UInteger
    Public hInstance As IntPtr
    Public lpPrintTemplateName As IntPtr
    Public lpCallback As IntPtr
    Public nPropertyPages As UInteger
    Public lphPropertyPages As IntPtr
    Public nStartPage As UInteger
    Public dwResultAction As UInteger
End Structure

import ctypes
from ctypes import wintypes

class PRINTDLGEXA(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("lStructSize", wintypes.DWORD),
        ("hwndOwner", ctypes.c_void_p),
        ("hDevMode", ctypes.c_void_p),
        ("hDevNames", ctypes.c_void_p),
        ("hDC", ctypes.c_void_p),
        ("Flags", wintypes.DWORD),
        ("Flags2", wintypes.DWORD),
        ("ExclusionFlags", wintypes.DWORD),
        ("nPageRanges", wintypes.DWORD),
        ("nMaxPageRanges", wintypes.DWORD),
        ("lpPageRanges", ctypes.c_void_p),
        ("nMinPage", wintypes.DWORD),
        ("nMaxPage", wintypes.DWORD),
        ("nCopies", wintypes.DWORD),
        ("hInstance", ctypes.c_void_p),
        ("lpPrintTemplateName", ctypes.c_void_p),
        ("lpCallback", ctypes.c_void_p),
        ("nPropertyPages", wintypes.DWORD),
        ("lphPropertyPages", ctypes.c_void_p),
        ("nStartPage", wintypes.DWORD),
        ("dwResultAction", wintypes.DWORD),
    ]

#[repr(C, packed(1))]
pub struct PRINTDLGEXA {
    pub lStructSize: u32,
    pub hwndOwner: *mut core::ffi::c_void,
    pub hDevMode: *mut core::ffi::c_void,
    pub hDevNames: *mut core::ffi::c_void,
    pub hDC: *mut core::ffi::c_void,
    pub Flags: u32,
    pub Flags2: u32,
    pub ExclusionFlags: u32,
    pub nPageRanges: u32,
    pub nMaxPageRanges: u32,
    pub lpPageRanges: *mut core::ffi::c_void,
    pub nMinPage: u32,
    pub nMaxPage: u32,
    pub nCopies: u32,
    pub hInstance: *mut core::ffi::c_void,
    pub lpPrintTemplateName: *mut core::ffi::c_void,
    pub lpCallback: *mut core::ffi::c_void,
    pub nPropertyPages: u32,
    pub lphPropertyPages: *mut core::ffi::c_void,
    pub nStartPage: u32,
    pub dwResultAction: u32,
}

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

type PRINTDLGEXA struct {
	lStructSize uint32
	hwndOwner uintptr
	hDevMode uintptr
	hDevNames uintptr
	hDC uintptr
	Flags uint32
	Flags2 uint32
	ExclusionFlags uint32
	nPageRanges uint32
	nMaxPageRanges uint32
	lpPageRanges uintptr
	nMinPage uint32
	nMaxPage uint32
	nCopies uint32
	hInstance uintptr
	lpPrintTemplateName uintptr
	lpCallback uintptr
	nPropertyPages uint32
	lphPropertyPages uintptr
	nStartPage uint32
	dwResultAction uint32
}

type
  PRINTDLGEXA = packed record
    lStructSize: DWORD;
    hwndOwner: Pointer;
    hDevMode: Pointer;
    hDevNames: Pointer;
    hDC: Pointer;
    Flags: DWORD;
    Flags2: DWORD;
    ExclusionFlags: DWORD;
    nPageRanges: DWORD;
    nMaxPageRanges: DWORD;
    lpPageRanges: Pointer;
    nMinPage: DWORD;
    nMaxPage: DWORD;
    nCopies: DWORD;
    hInstance: Pointer;
    lpPrintTemplateName: Pointer;
    lpCallback: Pointer;
    nPropertyPages: DWORD;
    lphPropertyPages: Pointer;
    nStartPage: DWORD;
    dwResultAction: DWORD;
  end;

const PRINTDLGEXA = extern struct {
    lStructSize: u32,
    hwndOwner: ?*anyopaque,
    hDevMode: ?*anyopaque,
    hDevNames: ?*anyopaque,
    hDC: ?*anyopaque,
    Flags: u32,
    Flags2: u32,
    ExclusionFlags: u32,
    nPageRanges: u32,
    nMaxPageRanges: u32,
    lpPageRanges: ?*anyopaque,
    nMinPage: u32,
    nMaxPage: u32,
    nCopies: u32,
    hInstance: ?*anyopaque,
    lpPrintTemplateName: ?*anyopaque,
    lpCallback: ?*anyopaque,
    nPropertyPages: u32,
    lphPropertyPages: ?*anyopaque,
    nStartPage: u32,
    dwResultAction: u32,
};

type
  PRINTDLGEXA {.packed.} = object
    lStructSize: uint32
    hwndOwner: pointer
    hDevMode: pointer
    hDevNames: pointer
    hDC: pointer
    Flags: uint32
    Flags2: uint32
    ExclusionFlags: uint32
    nPageRanges: uint32
    nMaxPageRanges: uint32
    lpPageRanges: pointer
    nMinPage: uint32
    nMaxPage: uint32
    nCopies: uint32
    hInstance: pointer
    lpPrintTemplateName: pointer
    lpCallback: pointer
    nPropertyPages: uint32
    lphPropertyPages: pointer
    nStartPage: uint32
    dwResultAction: uint32

align(1)
struct PRINTDLGEXA
{
    uint lStructSize;
    void* hwndOwner;
    void* hDevMode;
    void* hDevNames;
    void* hDC;
    uint Flags;
    uint Flags2;
    uint ExclusionFlags;
    uint nPageRanges;
    uint nMaxPageRanges;
    void* lpPageRanges;
    uint nMinPage;
    uint nMaxPage;
    uint nCopies;
    void* hInstance;
    void* lpPrintTemplateName;
    void* lpCallback;
    uint nPropertyPages;
    void* lphPropertyPages;
    uint nStartPage;
    uint dwResultAction;
}