NMREBARCHEVRON

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 RECT
{
    public int left;
    public int top;
    public int right;
    public int bottom;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NMREBARCHEVRON
{
    public NMHDR hdr;
    public uint uBand;
    public uint wID;
    public IntPtr lParam;
    public RECT rc;
    public IntPtr lParamNM;
}

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 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 NMREBARCHEVRON
    Public hdr As NMHDR
    Public uBand As UInteger
    Public wID As UInteger
    Public lParam As IntPtr
    Public rc As RECT
    Public lParamNM As IntPtr
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 RECT(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_int),
        ("top", ctypes.c_int),
        ("right", ctypes.c_int),
        ("bottom", ctypes.c_int),
    ]

class NMREBARCHEVRON(ctypes.Structure):
    _fields_ = [
        ("hdr", NMHDR),
        ("uBand", wintypes.DWORD),
        ("wID", wintypes.DWORD),
        ("lParam", ctypes.c_ssize_t),
        ("rc", RECT),
        ("lParamNM", ctypes.c_ssize_t),
    ]

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

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

#[repr(C)]
pub struct NMREBARCHEVRON {
    pub hdr: NMHDR,
    pub uBand: u32,
    pub wID: u32,
    pub lParam: isize,
    pub rc: RECT,
    pub lParamNM: isize,
}

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

type NMHDR struct {
	hwndFrom uintptr
	idFrom uintptr
	code uint32
}

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

type NMREBARCHEVRON struct {
	hdr NMHDR
	uBand uint32
	wID uint32
	lParam uintptr
	rc RECT
	lParamNM uintptr
}

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

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

  NMREBARCHEVRON = record
    hdr: NMHDR;
    uBand: DWORD;
    wID: DWORD;
    lParam: NativeInt;
    rc: RECT;
    lParamNM: NativeInt;
  end;

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

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

const NMREBARCHEVRON = extern struct {
    hdr: NMHDR,
    uBand: u32,
    wID: u32,
    lParam: isize,
    rc: RECT,
    lParamNM: isize,
};

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

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

  NMREBARCHEVRON {.bycopy.} = object
    hdr: NMHDR
    uBand: uint32
    wID: uint32
    lParam: int
    rc: RECT
    lParamNM: int

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

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

struct NMREBARCHEVRON
{
    NMHDR hdr;
    uint uBand;
    uint wID;
    ptrdiff_t lParam;
    RECT rc;
    ptrdiff_t lParamNM;
}