NMTBRESTORE

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 TBBUTTON
{
    public int iBitmap;
    public int idCommand;
    public byte fsState;
    public byte fsStyle;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public byte[] bReserved;
    public UIntPtr dwData;
    public IntPtr iString;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NMTBRESTORE
{
    public NMHDR hdr;
    public IntPtr pData;
    public IntPtr pCurrent;
    public uint cbData;
    public int iItem;
    public int cButtons;
    public int cbBytesPerRecord;
    public TBBUTTON tbButton;
}

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 TBBUTTON
    Public iBitmap As Integer
    Public idCommand As Integer
    Public fsState As Byte
    Public fsStyle As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=6)> Public bReserved() As Byte
    Public dwData As UIntPtr
    Public iString As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure NMTBRESTORE
    Public hdr As NMHDR
    Public pData As IntPtr
    Public pCurrent As IntPtr
    Public cbData As UInteger
    Public iItem As Integer
    Public cButtons As Integer
    Public cbBytesPerRecord As Integer
    Public tbButton As TBBUTTON
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 TBBUTTON(ctypes.Structure):
    _fields_ = [
        ("iBitmap", ctypes.c_int),
        ("idCommand", ctypes.c_int),
        ("fsState", ctypes.c_ubyte),
        ("fsStyle", ctypes.c_ubyte),
        ("bReserved", ctypes.c_ubyte * 6),
        ("dwData", ctypes.c_size_t),
        ("iString", ctypes.c_ssize_t),
    ]

class NMTBRESTORE(ctypes.Structure):
    _fields_ = [
        ("hdr", NMHDR),
        ("pData", ctypes.c_void_p),
        ("pCurrent", ctypes.c_void_p),
        ("cbData", wintypes.DWORD),
        ("iItem", ctypes.c_int),
        ("cButtons", ctypes.c_int),
        ("cbBytesPerRecord", ctypes.c_int),
        ("tbButton", TBBUTTON),
    ]

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

#[repr(C)]
pub struct TBBUTTON {
    pub iBitmap: i32,
    pub idCommand: i32,
    pub fsState: u8,
    pub fsStyle: u8,
    pub bReserved: [u8; 6],
    pub dwData: usize,
    pub iString: isize,
}

#[repr(C)]
pub struct NMTBRESTORE {
    pub hdr: NMHDR,
    pub pData: *mut core::ffi::c_void,
    pub pCurrent: *mut core::ffi::c_void,
    pub cbData: u32,
    pub iItem: i32,
    pub cButtons: i32,
    pub cbBytesPerRecord: i32,
    pub tbButton: TBBUTTON,
}

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

type NMHDR struct {
	hwndFrom uintptr
	idFrom uintptr
	code uint32
}

type TBBUTTON struct {
	iBitmap int32
	idCommand int32
	fsState byte
	fsStyle byte
	bReserved [6]byte
	dwData uintptr
	iString uintptr
}

type NMTBRESTORE struct {
	hdr NMHDR
	pData uintptr
	pCurrent uintptr
	cbData uint32
	iItem int32
	cButtons int32
	cbBytesPerRecord int32
	tbButton TBBUTTON
}

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

  TBBUTTON = record
    iBitmap: Integer;
    idCommand: Integer;
    fsState: Byte;
    fsStyle: Byte;
    bReserved: array[0..5] of Byte;
    dwData: NativeUInt;
    iString: NativeInt;
  end;

  NMTBRESTORE = record
    hdr: NMHDR;
    pData: Pointer;
    pCurrent: Pointer;
    cbData: DWORD;
    iItem: Integer;
    cButtons: Integer;
    cbBytesPerRecord: Integer;
    tbButton: TBBUTTON;
  end;

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

const TBBUTTON = extern struct {
    iBitmap: i32,
    idCommand: i32,
    fsState: u8,
    fsStyle: u8,
    bReserved: [6]u8,
    dwData: usize,
    iString: isize,
};

const NMTBRESTORE = extern struct {
    hdr: NMHDR,
    pData: ?*anyopaque,
    pCurrent: ?*anyopaque,
    cbData: u32,
    iItem: i32,
    cButtons: i32,
    cbBytesPerRecord: i32,
    tbButton: TBBUTTON,
};

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

  TBBUTTON {.bycopy.} = object
    iBitmap: int32
    idCommand: int32
    fsState: uint8
    fsStyle: uint8
    bReserved: array[6, uint8]
    dwData: uint
    iString: int

  NMTBRESTORE {.bycopy.} = object
    hdr: NMHDR
    pData: pointer
    pCurrent: pointer
    cbData: uint32
    iItem: int32
    cButtons: int32
    cbBytesPerRecord: int32
    tbButton: TBBUTTON

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

struct TBBUTTON
{
    int iBitmap;
    int idCommand;
    ubyte fsState;
    ubyte fsStyle;
    ubyte[6] bReserved;
    size_t dwData;
    ptrdiff_t iString;
}

struct NMTBRESTORE
{
    NMHDR hdr;
    void* pData;
    void* pCurrent;
    uint cbData;
    int iItem;
    int cButtons;
    int cbBytesPerRecord;
    TBBUTTON tbButton;
}