DDHAL_LOCKDATA

using System;
using System.Runtime.InteropServices;

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DDHAL_LOCKDATA
{
    public IntPtr lpDD;
    public IntPtr lpDDSurface;
    public uint bHasRect;
    public RECTL rArea;
    public IntPtr lpSurfData;
    public int ddRVal;
    public IntPtr Lock;
    public uint dwFlags;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECTL
    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 DDHAL_LOCKDATA
    Public lpDD As IntPtr
    Public lpDDSurface As IntPtr
    Public bHasRect As UInteger
    Public rArea As RECTL
    Public lpSurfData As IntPtr
    Public ddRVal As Integer
    Public Lock As IntPtr
    Public dwFlags As UInteger
End Structure

import ctypes
from ctypes import wintypes

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

class DDHAL_LOCKDATA(ctypes.Structure):
    _fields_ = [
        ("lpDD", ctypes.c_void_p),
        ("lpDDSurface", ctypes.c_void_p),
        ("bHasRect", wintypes.DWORD),
        ("rArea", RECTL),
        ("lpSurfData", ctypes.c_void_p),
        ("ddRVal", ctypes.c_int),
        ("Lock", ctypes.c_void_p),
        ("dwFlags", wintypes.DWORD),
    ]

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

#[repr(C)]
pub struct DDHAL_LOCKDATA {
    pub lpDD: *mut core::ffi::c_void,
    pub lpDDSurface: *mut core::ffi::c_void,
    pub bHasRect: u32,
    pub rArea: RECTL,
    pub lpSurfData: *mut core::ffi::c_void,
    pub ddRVal: i32,
    pub Lock: *mut core::ffi::c_void,
    pub dwFlags: u32,
}

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

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

type DDHAL_LOCKDATA struct {
	lpDD uintptr
	lpDDSurface uintptr
	bHasRect uint32
	rArea RECTL
	lpSurfData uintptr
	ddRVal int32
	Lock uintptr
	dwFlags uint32
}

type
  RECTL = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

  DDHAL_LOCKDATA = record
    lpDD: Pointer;
    lpDDSurface: Pointer;
    bHasRect: DWORD;
    rArea: RECTL;
    lpSurfData: Pointer;
    ddRVal: Integer;
    Lock: Pointer;
    dwFlags: DWORD;
  end;

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

const DDHAL_LOCKDATA = extern struct {
    lpDD: ?*anyopaque,
    lpDDSurface: ?*anyopaque,
    bHasRect: u32,
    rArea: RECTL,
    lpSurfData: ?*anyopaque,
    ddRVal: i32,
    Lock: ?*anyopaque,
    dwFlags: u32,
};

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

  DDHAL_LOCKDATA {.bycopy.} = object
    lpDD: pointer
    lpDDSurface: pointer
    bHasRect: uint32
    rArea: RECTL
    lpSurfData: pointer
    ddRVal: int32
    Lock: pointer
    dwFlags: uint32

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

struct DDHAL_LOCKDATA
{
    void* lpDD;
    void* lpDDSurface;
    uint bHasRect;
    RECTL rArea;
    void* lpSurfData;
    int ddRVal;
    void* Lock;
    uint dwFlags;
}