DD_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 DD_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;
    public UIntPtr fpProcess;
}

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 DD_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
    Public fpProcess As UIntPtr
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 DD_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),
        ("fpProcess", ctypes.c_size_t),
    ]

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

#[repr(C)]
pub struct DD_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,
    pub fpProcess: usize,
}

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

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

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

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

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

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

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

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

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

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

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