DCIENUMINPUT

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DCICMD
{
    public uint dwCommand;
    public uint dwParam1;
    public uint dwParam2;
    public uint dwVersion;
    public uint dwReserved;
}

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DCIENUMINPUT
{
    public DCICMD cmd;
    public RECT rSrc;
    public RECT rDst;
    public IntPtr EnumCallback;
    public IntPtr lpContext;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DCICMD
    Public dwCommand As UInteger
    Public dwParam1 As UInteger
    Public dwParam2 As UInteger
    Public dwVersion As UInteger
    Public dwReserved As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECT
    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 DCIENUMINPUT
    Public cmd As DCICMD
    Public rSrc As RECT
    Public rDst As RECT
    Public EnumCallback As IntPtr
    Public lpContext As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class DCICMD(ctypes.Structure):
    _fields_ = [
        ("dwCommand", wintypes.DWORD),
        ("dwParam1", wintypes.DWORD),
        ("dwParam2", wintypes.DWORD),
        ("dwVersion", wintypes.DWORD),
        ("dwReserved", wintypes.DWORD),
    ]

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

class DCIENUMINPUT(ctypes.Structure):
    _fields_ = [
        ("cmd", DCICMD),
        ("rSrc", RECT),
        ("rDst", RECT),
        ("EnumCallback", ctypes.c_ssize_t),
        ("lpContext", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct DCICMD {
    pub dwCommand: u32,
    pub dwParam1: u32,
    pub dwParam2: u32,
    pub dwVersion: u32,
    pub dwReserved: u32,
}

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

#[repr(C)]
pub struct DCIENUMINPUT {
    pub cmd: DCICMD,
    pub rSrc: RECT,
    pub rDst: RECT,
    pub EnumCallback: isize,
    pub lpContext: *mut core::ffi::c_void,
}

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

type DCICMD struct {
	dwCommand uint32
	dwParam1 uint32
	dwParam2 uint32
	dwVersion uint32
	dwReserved uint32
}

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

type DCIENUMINPUT struct {
	cmd DCICMD
	rSrc RECT
	rDst RECT
	EnumCallback uintptr
	lpContext uintptr
}

type
  DCICMD = record
    dwCommand: DWORD;
    dwParam1: DWORD;
    dwParam2: DWORD;
    dwVersion: DWORD;
    dwReserved: DWORD;
  end;

  RECT = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

  DCIENUMINPUT = record
    cmd: DCICMD;
    rSrc: RECT;
    rDst: RECT;
    EnumCallback: NativeInt;
    lpContext: Pointer;
  end;

const DCICMD = extern struct {
    dwCommand: u32,
    dwParam1: u32,
    dwParam2: u32,
    dwVersion: u32,
    dwReserved: u32,
};

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

const DCIENUMINPUT = extern struct {
    cmd: DCICMD,
    rSrc: RECT,
    rDst: RECT,
    EnumCallback: isize,
    lpContext: ?*anyopaque,
};

type
  DCICMD {.bycopy.} = object
    dwCommand: uint32
    dwParam1: uint32
    dwParam2: uint32
    dwVersion: uint32
    dwReserved: uint32

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

  DCIENUMINPUT {.bycopy.} = object
    cmd: DCICMD
    rSrc: RECT
    rDst: RECT
    EnumCallback: int
    lpContext: pointer

struct DCICMD
{
    uint dwCommand;
    uint dwParam1;
    uint dwParam2;
    uint dwVersion;
    uint dwReserved;
}

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

struct DCIENUMINPUT
{
    DCICMD cmd;
    RECT rSrc;
    RECT rDst;
    ptrdiff_t EnumCallback;
    void* lpContext;
}