NMDATETIMEFORMATA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NMHDR
{
    public IntPtr hwndFrom;
    public UIntPtr idFrom;
    public uint code;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SYSTEMTIME
{
    public ushort wYear;
    public ushort wMonth;
    public ushort wDayOfWeek;
    public ushort wDay;
    public ushort wHour;
    public ushort wMinute;
    public ushort wSecond;
    public ushort wMilliseconds;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NMDATETIMEFORMATA
{
    public NMHDR nmhdr;
    public IntPtr pszFormat;
    public SYSTEMTIME st;
    public IntPtr pszDisplay;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] public sbyte[] szDisplay;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure NMHDR
    Public hwndFrom As IntPtr
    Public idFrom As UIntPtr
    Public code As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SYSTEMTIME
    Public wYear As UShort
    Public wMonth As UShort
    Public wDayOfWeek As UShort
    Public wDay As UShort
    Public wHour As UShort
    Public wMinute As UShort
    Public wSecond As UShort
    Public wMilliseconds As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure NMDATETIMEFORMATA
    Public nmhdr As NMHDR
    Public pszFormat As IntPtr
    Public st As SYSTEMTIME
    Public pszDisplay As IntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=64)> Public szDisplay() As SByte
End Structure

import ctypes
from ctypes import wintypes

class NMHDR(ctypes.Structure):
    _fields_ = [
        ("hwndFrom", ctypes.c_void_p),
        ("idFrom", ctypes.c_size_t),
        ("code", wintypes.DWORD),
    ]

class SYSTEMTIME(ctypes.Structure):
    _fields_ = [
        ("wYear", ctypes.c_ushort),
        ("wMonth", ctypes.c_ushort),
        ("wDayOfWeek", ctypes.c_ushort),
        ("wDay", ctypes.c_ushort),
        ("wHour", ctypes.c_ushort),
        ("wMinute", ctypes.c_ushort),
        ("wSecond", ctypes.c_ushort),
        ("wMilliseconds", ctypes.c_ushort),
    ]

class NMDATETIMEFORMATA(ctypes.Structure):
    _fields_ = [
        ("nmhdr", NMHDR),
        ("pszFormat", ctypes.c_void_p),
        ("st", SYSTEMTIME),
        ("pszDisplay", ctypes.c_void_p),
        ("szDisplay", ctypes.c_byte * 64),
    ]

#[repr(C)]
pub struct NMHDR {
    pub hwndFrom: *mut core::ffi::c_void,
    pub idFrom: usize,
    pub code: u32,
}

#[repr(C)]
pub struct SYSTEMTIME {
    pub wYear: u16,
    pub wMonth: u16,
    pub wDayOfWeek: u16,
    pub wDay: u16,
    pub wHour: u16,
    pub wMinute: u16,
    pub wSecond: u16,
    pub wMilliseconds: u16,
}

#[repr(C)]
pub struct NMDATETIMEFORMATA {
    pub nmhdr: NMHDR,
    pub pszFormat: *mut core::ffi::c_void,
    pub st: SYSTEMTIME,
    pub pszDisplay: *mut core::ffi::c_void,
    pub szDisplay: [i8; 64],
}

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

type NMHDR struct {
	hwndFrom uintptr
	idFrom uintptr
	code uint32
}

type SYSTEMTIME struct {
	wYear uint16
	wMonth uint16
	wDayOfWeek uint16
	wDay uint16
	wHour uint16
	wMinute uint16
	wSecond uint16
	wMilliseconds uint16
}

type NMDATETIMEFORMATA struct {
	nmhdr NMHDR
	pszFormat uintptr
	st SYSTEMTIME
	pszDisplay uintptr
	szDisplay [64]int8
}

type
  NMHDR = record
    hwndFrom: Pointer;
    idFrom: NativeUInt;
    code: DWORD;
  end;

  SYSTEMTIME = record
    wYear: Word;
    wMonth: Word;
    wDayOfWeek: Word;
    wDay: Word;
    wHour: Word;
    wMinute: Word;
    wSecond: Word;
    wMilliseconds: Word;
  end;

  NMDATETIMEFORMATA = record
    nmhdr: NMHDR;
    pszFormat: Pointer;
    st: SYSTEMTIME;
    pszDisplay: Pointer;
    szDisplay: array[0..63] of Shortint;
  end;

const NMHDR = extern struct {
    hwndFrom: ?*anyopaque,
    idFrom: usize,
    code: u32,
};

const SYSTEMTIME = extern struct {
    wYear: u16,
    wMonth: u16,
    wDayOfWeek: u16,
    wDay: u16,
    wHour: u16,
    wMinute: u16,
    wSecond: u16,
    wMilliseconds: u16,
};

const NMDATETIMEFORMATA = extern struct {
    nmhdr: NMHDR,
    pszFormat: ?*anyopaque,
    st: SYSTEMTIME,
    pszDisplay: ?*anyopaque,
    szDisplay: [64]i8,
};

type
  NMHDR {.bycopy.} = object
    hwndFrom: pointer
    idFrom: uint
    code: uint32

  SYSTEMTIME {.bycopy.} = object
    wYear: uint16
    wMonth: uint16
    wDayOfWeek: uint16
    wDay: uint16
    wHour: uint16
    wMinute: uint16
    wSecond: uint16
    wMilliseconds: uint16

  NMDATETIMEFORMATA {.bycopy.} = object
    nmhdr: NMHDR
    pszFormat: pointer
    st: SYSTEMTIME
    pszDisplay: pointer
    szDisplay: array[64, int8]

struct NMHDR
{
    void* hwndFrom;
    size_t idFrom;
    uint code;
}

struct SYSTEMTIME
{
    ushort wYear;
    ushort wMonth;
    ushort wDayOfWeek;
    ushort wDay;
    ushort wHour;
    ushort wMinute;
    ushort wSecond;
    ushort wMilliseconds;
}

struct NMDATETIMEFORMATA
{
    NMHDR nmhdr;
    void* pszFormat;
    SYSTEMTIME st;
    void* pszDisplay;
    byte[64] szDisplay;
}