Win32 API 日本語リファレンス
ホーム › Globalization › ScriptPlaceOpenType

ScriptPlaceOpenType

関数
OpenType機能を用いてグリフの位置と幅を算出する。
DLLUSP10.dll呼出規約winapi対応OSWindows Vista 以降
📘 Microsoft Learn (日本語) · English

シグネチャ

// USP10.dll
#include <windows.h>

HRESULT ScriptPlaceOpenType(
    HDC hdc,   // optional
    void** psc,
    SCRIPT_ANALYSIS* psa,
    DWORD tagScript,
    DWORD tagLangSys,
    INT* rcRangeChars,   // optional
    TEXTRANGE_PROPERTIES** rpRangeProperties,   // optional
    INT cRanges,
    LPCWSTR pwcChars,
    WORD* pwLogClust,
    SCRIPT_CHARPROP* pCharProps,
    INT cChars,
    const WORD* pwGlyphs,
    const SCRIPT_GLYPHPROP* pGlyphProps,
    INT cGlyphs,
    INT* piAdvance,
    GOFFSET* pGoffset,
    ABC* pABC   // optional
);

パラメーター

名前型方向説明
hdcHDCinoptionalデバイスコンテキストのハンドル。詳細については、Caching を参照してください。
pscvoid**inoutスクリプトキャッシュを識別する SCRIPT_CACHE 構造体へのポインター。
psaSCRIPT_ANALYSIS*inout

以前の ScriptItemizeOpenType 呼び出しから取得した SCRIPT_ANALYSIS 構造体へのポインター。この構造体は、生成されるグリフのリスト、それに関連付けられた幅、および x・y の配置オフセットを制御するシェーピングエンジンを識別します。

また、アプリケーションはこのパラメーターに NULL を設定して、フィルタリングされていない結果を受け取ることもできます。

tagScriptDWORDin使用する文字体系の OpenType スクリプトタグを格納した OPENTYPE_TAG 構造体。
tagLangSysDWORDin文字体系の OpenType 言語タグを格納した OPENTYPE_TAG 構造体。
rcRangeCharsINT*inoptional各範囲に含まれる文字数の配列。要素数は cRanges パラメーターで示されます。値の合計は cChars の値と等しくなる必要があります。
rpRangePropertiesTEXTRANGE_PROPERTIES**inoptional各範囲のプロパティを定義する TEXTRANGE_PROPERTIES 構造体の配列。要素数は cRanges パラメーターで定義されます。
cRangesINTinOpenType 機能範囲の数。
pwcCharsLPCWSTRinランを構成する Unicode 文字の配列へのポインター。要素数は cRanges パラメーターで定義されます。
pwLogClustWORD*in論理クラスター情報の配列へのポインター。配列の各要素は、pwcChars で定義される配列内の文字に対応します。各要素の値は、ラン内の最初のグリフから、対応する文字を含むクラスターの最初のグリフまでのオフセットです。SCRIPT_ANALYSIS 構造体の fRTL メンバーが TRUE に設定されている場合、pwLogClust の要素は配列を読み進めるにつれて減少することに注意してください。
pCharPropsSCRIPT_CHARPROP*inUnicode ラン内の文字プロパティ値の配列へのポインター。
cCharsINTinUnicode ラン内の文字数。
pwGlyphsWORD*in以前の ScriptShapeOpenType 関数の呼び出しから取得したグリフバッファーへのポインター。
pGlyphPropsSCRIPT_GLYPHPROP*in取得する各グリフの属性の配列へのポインター。値の数は cGlyphs の値と等しくなります。グリフごとに 1 つのグリフプロパティが存在するため、このパラメーターの要素数は cGlyphs で示されます。
cGlyphsINTinグリフ配列バッファー内のグリフ数。
piAdvanceINT*outこの関数が advance width(送り幅)情報を取得する、cGlyphs で示される長さの配列へのポインター。
pGoffsetGOFFSET*outこの関数が結合グリフの x・y オフセットを取得する GOFFSET 構造体の配列へのポインター。この配列の長さは cGlyphs で示される値である必要があります。
pABCABC*outoptionalこの関数が run 全体の ABC width(ABC 幅)を取得する ABC 構造体へのポインター。

戻り値の型: HRESULT

公式ドキュメント

ScriptShapeOpenType の出力に基づき、OpenType 情報を用いて Unicode ラン(run)のグリフと視覚的な属性を生成します。

戻り値

成功した場合は 0 を返します。失敗した場合は 0 以外の HRESULT 値を返します。すべてのエラーケースにおいて、出力値は未定義です。アプリケーションは SUCCEEDED および FAILED マクロを使用して戻り値をテストできます。

cGlyphs で示される出力バッファーの長さが小さすぎる場合、この関数は E_OUTOFMEMORY を返します。アプリケーションは、より大きなバッファーで再度呼び出すことを試みることができます。

psc パラメーターで指定されたスクリプトキャッシュにグリフを配置するための十分な情報が含まれておらず、かつ hdc パラメーターが NULL として渡されたために関数が配置処理を完了できない場合、この関数は E_PENDING を返します。アプリケーションは、ランに対して正しいデバイスコンテキストを設定し、hdc に適切な値を指定したうえで、他のすべてのパラメーターを同じにしてこの関数を再度呼び出す必要があります。

解説(Remarks)

この関数は、古い ScriptPlace 関数よりも推奨されます。ScriptPlaceOpenType の利点には次のようなものがあります。

項目全体の合成 ABC 幅は、グリフが開始位置の左側、および送り幅の合計が示す長さの右側にどれだけ overhang(はみ出し)するかを示します。行の合計送り幅は正確に abcA+abcB+abcC となります。abcA 値と abcC 値は、セル高さに対する割合として 8 ビットで保持されるため、おおよそ +/-1 パーセントの精度です。取得される合計幅、すなわち piAdvance が示す abcA+abcB+abcC 値の合計は、TrueType シェーピングエンジンの解像度の精度で求められます。

psa パラメーターで示される SCRIPT_ANALYSIS 構造体の fLogicalOrder メンバーが設定されていない限り、すべての配列は視覚順(visual order)で並びます。

重要 Windows 8 以降: Windows 7 で実行する能力を維持するために、Uniscribe を使用するモジュールは、ライブラリリスト内で gdi32.lib よりも前に Usp10.lib を指定する必要があります。
出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での呼び出し定義

// USP10.dll
#include <windows.h>

HRESULT ScriptPlaceOpenType(
    HDC hdc,   // optional
    void** psc,
    SCRIPT_ANALYSIS* psa,
    DWORD tagScript,
    DWORD tagLangSys,
    INT* rcRangeChars,   // optional
    TEXTRANGE_PROPERTIES** rpRangeProperties,   // optional
    INT cRanges,
    LPCWSTR pwcChars,
    WORD* pwLogClust,
    SCRIPT_CHARPROP* pCharProps,
    INT cChars,
    const WORD* pwGlyphs,
    const SCRIPT_GLYPHPROP* pGlyphProps,
    INT cGlyphs,
    INT* piAdvance,
    GOFFSET* pGoffset,
    ABC* pABC   // optional
);
[DllImport("USP10.dll", ExactSpelling = true)]
static extern int ScriptPlaceOpenType(
    IntPtr hdc,   // HDC optional
    IntPtr psc,   // void** in/out
    IntPtr psa,   // SCRIPT_ANALYSIS* in/out
    uint tagScript,   // DWORD
    uint tagLangSys,   // DWORD
    IntPtr rcRangeChars,   // INT* optional
    IntPtr rpRangeProperties,   // TEXTRANGE_PROPERTIES** optional
    int cRanges,   // INT
    [MarshalAs(UnmanagedType.LPWStr)] string pwcChars,   // LPCWSTR
    ref ushort pwLogClust,   // WORD*
    IntPtr pCharProps,   // SCRIPT_CHARPROP*
    int cChars,   // INT
    ref ushort pwGlyphs,   // WORD*
    IntPtr pGlyphProps,   // SCRIPT_GLYPHPROP*
    int cGlyphs,   // INT
    out int piAdvance,   // INT* out
    IntPtr pGoffset,   // GOFFSET* out
    IntPtr pABC   // ABC* optional, out
);
<DllImport("USP10.dll", ExactSpelling:=True)>
Public Shared Function ScriptPlaceOpenType(
    hdc As IntPtr,   ' HDC optional
    psc As IntPtr,   ' void** in/out
    psa As IntPtr,   ' SCRIPT_ANALYSIS* in/out
    tagScript As UInteger,   ' DWORD
    tagLangSys As UInteger,   ' DWORD
    rcRangeChars As IntPtr,   ' INT* optional
    rpRangeProperties As IntPtr,   ' TEXTRANGE_PROPERTIES** optional
    cRanges As Integer,   ' INT
    <MarshalAs(UnmanagedType.LPWStr)> pwcChars As String,   ' LPCWSTR
    ByRef pwLogClust As UShort,   ' WORD*
    pCharProps As IntPtr,   ' SCRIPT_CHARPROP*
    cChars As Integer,   ' INT
    ByRef pwGlyphs As UShort,   ' WORD*
    pGlyphProps As IntPtr,   ' SCRIPT_GLYPHPROP*
    cGlyphs As Integer,   ' INT
    <Out> ByRef piAdvance As Integer,   ' INT* out
    pGoffset As IntPtr,   ' GOFFSET* out
    pABC As IntPtr   ' ABC* optional, out
) As Integer
End Function
' hdc : HDC optional
' psc : void** in/out
' psa : SCRIPT_ANALYSIS* in/out
' tagScript : DWORD
' tagLangSys : DWORD
' rcRangeChars : INT* optional
' rpRangeProperties : TEXTRANGE_PROPERTIES** optional
' cRanges : INT
' pwcChars : LPCWSTR
' pwLogClust : WORD*
' pCharProps : SCRIPT_CHARPROP*
' cChars : INT
' pwGlyphs : WORD*
' pGlyphProps : SCRIPT_GLYPHPROP*
' cGlyphs : INT
' piAdvance : INT* out
' pGoffset : GOFFSET* out
' pABC : ABC* optional, out
Declare PtrSafe Function ScriptPlaceOpenType Lib "usp10" ( _
    ByVal hdc As LongPtr, _
    ByVal psc As LongPtr, _
    ByVal psa As LongPtr, _
    ByVal tagScript As Long, _
    ByVal tagLangSys As Long, _
    ByVal rcRangeChars As LongPtr, _
    ByVal rpRangeProperties As LongPtr, _
    ByVal cRanges As Long, _
    ByVal pwcChars As LongPtr, _
    ByRef pwLogClust As Integer, _
    ByVal pCharProps As LongPtr, _
    ByVal cChars As Long, _
    ByRef pwGlyphs As Integer, _
    ByVal pGlyphProps As LongPtr, _
    ByVal cGlyphs As Long, _
    ByRef piAdvance As Long, _
    ByVal pGoffset As LongPtr, _
    ByVal pABC As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。
import ctypes
from ctypes import wintypes

ScriptPlaceOpenType = ctypes.windll.usp10.ScriptPlaceOpenType
ScriptPlaceOpenType.restype = ctypes.c_int
ScriptPlaceOpenType.argtypes = [
    wintypes.HANDLE,  # hdc : HDC optional
    ctypes.c_void_p,  # psc : void** in/out
    ctypes.c_void_p,  # psa : SCRIPT_ANALYSIS* in/out
    wintypes.DWORD,  # tagScript : DWORD
    wintypes.DWORD,  # tagLangSys : DWORD
    ctypes.POINTER(ctypes.c_int),  # rcRangeChars : INT* optional
    ctypes.c_void_p,  # rpRangeProperties : TEXTRANGE_PROPERTIES** optional
    ctypes.c_int,  # cRanges : INT
    wintypes.LPCWSTR,  # pwcChars : LPCWSTR
    ctypes.POINTER(ctypes.c_ushort),  # pwLogClust : WORD*
    ctypes.c_void_p,  # pCharProps : SCRIPT_CHARPROP*
    ctypes.c_int,  # cChars : INT
    ctypes.POINTER(ctypes.c_ushort),  # pwGlyphs : WORD*
    ctypes.c_void_p,  # pGlyphProps : SCRIPT_GLYPHPROP*
    ctypes.c_int,  # cGlyphs : INT
    ctypes.POINTER(ctypes.c_int),  # piAdvance : INT* out
    ctypes.c_void_p,  # pGoffset : GOFFSET* out
    ctypes.c_void_p,  # pABC : ABC* optional, out
]
require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('USP10.dll')
ScriptPlaceOpenType = Fiddle::Function.new(
  lib['ScriptPlaceOpenType'],
  [
    Fiddle::TYPE_VOIDP,  # hdc : HDC optional
    Fiddle::TYPE_VOIDP,  # psc : void** in/out
    Fiddle::TYPE_VOIDP,  # psa : SCRIPT_ANALYSIS* in/out
    -Fiddle::TYPE_INT,  # tagScript : DWORD
    -Fiddle::TYPE_INT,  # tagLangSys : DWORD
    Fiddle::TYPE_VOIDP,  # rcRangeChars : INT* optional
    Fiddle::TYPE_VOIDP,  # rpRangeProperties : TEXTRANGE_PROPERTIES** optional
    Fiddle::TYPE_INT,  # cRanges : INT
    Fiddle::TYPE_VOIDP,  # pwcChars : LPCWSTR
    Fiddle::TYPE_VOIDP,  # pwLogClust : WORD*
    Fiddle::TYPE_VOIDP,  # pCharProps : SCRIPT_CHARPROP*
    Fiddle::TYPE_INT,  # cChars : INT
    Fiddle::TYPE_VOIDP,  # pwGlyphs : WORD*
    Fiddle::TYPE_VOIDP,  # pGlyphProps : SCRIPT_GLYPHPROP*
    Fiddle::TYPE_INT,  # cGlyphs : INT
    Fiddle::TYPE_VOIDP,  # piAdvance : INT* out
    Fiddle::TYPE_VOIDP,  # pGoffset : GOFFSET* out
    Fiddle::TYPE_VOIDP,  # pABC : ABC* optional, out
  ],
  Fiddle::TYPE_INT)
#[link(name = "usp10")]
extern "system" {
    fn ScriptPlaceOpenType(
        hdc: *mut core::ffi::c_void,  // HDC optional
        psc: *mut *mut (),  // void** in/out
        psa: *mut SCRIPT_ANALYSIS,  // SCRIPT_ANALYSIS* in/out
        tagScript: u32,  // DWORD
        tagLangSys: u32,  // DWORD
        rcRangeChars: *mut i32,  // INT* optional
        rpRangeProperties: *mut *mut TEXTRANGE_PROPERTIES,  // TEXTRANGE_PROPERTIES** optional
        cRanges: i32,  // INT
        pwcChars: *const u16,  // LPCWSTR
        pwLogClust: *mut u16,  // WORD*
        pCharProps: *mut SCRIPT_CHARPROP,  // SCRIPT_CHARPROP*
        cChars: i32,  // INT
        pwGlyphs: *const u16,  // WORD*
        pGlyphProps: *const SCRIPT_GLYPHPROP,  // SCRIPT_GLYPHPROP*
        cGlyphs: i32,  // INT
        piAdvance: *mut i32,  // INT* out
        pGoffset: *mut GOFFSET,  // GOFFSET* out
        pABC: *mut ABC  // ABC* optional, out
    ) -> i32;
}
// crates: windows-sys provides ready-made bindings for this API.
$sig = @"
[DllImport("USP10.dll")]
public static extern int ScriptPlaceOpenType(IntPtr hdc, IntPtr psc, IntPtr psa, uint tagScript, uint tagLangSys, IntPtr rcRangeChars, IntPtr rpRangeProperties, int cRanges, [MarshalAs(UnmanagedType.LPWStr)] string pwcChars, ref ushort pwLogClust, IntPtr pCharProps, int cChars, ref ushort pwGlyphs, IntPtr pGlyphProps, int cGlyphs, out int piAdvance, IntPtr pGoffset, IntPtr pABC);
"@
$api = Add-Type -MemberDefinition $sig -Name 'USP10_ScriptPlaceOpenType' -Namespace Win32 -PassThru
# $api::ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
#uselib "USP10.dll"
#func global ScriptPlaceOpenType "ScriptPlaceOpenType" sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr
; ScriptPlaceOpenType hdc, psc, varptr(psa), tagScript, tagLangSys, varptr(rcRangeChars), varptr(rpRangeProperties), cRanges, pwcChars, varptr(pwLogClust), varptr(pCharProps), cChars, varptr(pwGlyphs), varptr(pGlyphProps), cGlyphs, varptr(piAdvance), varptr(pGoffset), varptr(pABC)   ; 戻り値は stat
; hdc : HDC optional -> "sptr"
; psc : void** in/out -> "sptr"
; psa : SCRIPT_ANALYSIS* in/out -> "sptr"
; tagScript : DWORD -> "sptr"
; tagLangSys : DWORD -> "sptr"
; rcRangeChars : INT* optional -> "sptr"
; rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> "sptr"
; cRanges : INT -> "sptr"
; pwcChars : LPCWSTR -> "sptr"
; pwLogClust : WORD* -> "sptr"
; pCharProps : SCRIPT_CHARPROP* -> "sptr"
; cChars : INT -> "sptr"
; pwGlyphs : WORD* -> "sptr"
; pGlyphProps : SCRIPT_GLYPHPROP* -> "sptr"
; cGlyphs : INT -> "sptr"
; piAdvance : INT* out -> "sptr"
; pGoffset : GOFFSET* out -> "sptr"
; pABC : ABC* optional, out -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。
出力引数: 
#uselib "USP10.dll"
#cfunc global ScriptPlaceOpenType "ScriptPlaceOpenType" sptr, sptr, var, int, int, var, var, int, wstr, var, var, int, var, var, int, var, var, var
; res = ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
; hdc : HDC optional -> "sptr"
; psc : void** in/out -> "sptr"
; psa : SCRIPT_ANALYSIS* in/out -> "var"
; tagScript : DWORD -> "int"
; tagLangSys : DWORD -> "int"
; rcRangeChars : INT* optional -> "var"
; rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> "var"
; cRanges : INT -> "int"
; pwcChars : LPCWSTR -> "wstr"
; pwLogClust : WORD* -> "var"
; pCharProps : SCRIPT_CHARPROP* -> "var"
; cChars : INT -> "int"
; pwGlyphs : WORD* -> "var"
; pGlyphProps : SCRIPT_GLYPHPROP* -> "var"
; cGlyphs : INT -> "int"
; piAdvance : INT* out -> "var"
; pGoffset : GOFFSET* out -> "var"
; pABC : ABC* optional, out -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
出力引数: 
; HRESULT ScriptPlaceOpenType(HDC hdc, void** psc, SCRIPT_ANALYSIS* psa, DWORD tagScript, DWORD tagLangSys, INT* rcRangeChars, TEXTRANGE_PROPERTIES** rpRangeProperties, INT cRanges, LPCWSTR pwcChars, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProps, INT cChars, WORD* pwGlyphs, SCRIPT_GLYPHPROP* pGlyphProps, INT cGlyphs, INT* piAdvance, GOFFSET* pGoffset, ABC* pABC)
#uselib "USP10.dll"
#cfunc global ScriptPlaceOpenType "ScriptPlaceOpenType" intptr, intptr, var, int, int, var, var, int, wstr, var, var, int, var, var, int, var, var, var
; res = ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
; hdc : HDC optional -> "intptr"
; psc : void** in/out -> "intptr"
; psa : SCRIPT_ANALYSIS* in/out -> "var"
; tagScript : DWORD -> "int"
; tagLangSys : DWORD -> "int"
; rcRangeChars : INT* optional -> "var"
; rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> "var"
; cRanges : INT -> "int"
; pwcChars : LPCWSTR -> "wstr"
; pwLogClust : WORD* -> "var"
; pCharProps : SCRIPT_CHARPROP* -> "var"
; cChars : INT -> "int"
; pwGlyphs : WORD* -> "var"
; pGlyphProps : SCRIPT_GLYPHPROP* -> "var"
; cGlyphs : INT -> "int"
; piAdvance : INT* out -> "var"
; pGoffset : GOFFSET* out -> "var"
; pABC : ABC* optional, out -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	usp10 = windows.NewLazySystemDLL("USP10.dll")
	procScriptPlaceOpenType = usp10.NewProc("ScriptPlaceOpenType")
)

// hdc (HDC optional), psc (void** in/out), psa (SCRIPT_ANALYSIS* in/out), tagScript (DWORD), tagLangSys (DWORD), rcRangeChars (INT* optional), rpRangeProperties (TEXTRANGE_PROPERTIES** optional), cRanges (INT), pwcChars (LPCWSTR), pwLogClust (WORD*), pCharProps (SCRIPT_CHARPROP*), cChars (INT), pwGlyphs (WORD*), pGlyphProps (SCRIPT_GLYPHPROP*), cGlyphs (INT), piAdvance (INT* out), pGoffset (GOFFSET* out), pABC (ABC* optional, out)
r1, _, err := procScriptPlaceOpenType.Call(
	uintptr(hdc),
	uintptr(psc),
	uintptr(psa),
	uintptr(tagScript),
	uintptr(tagLangSys),
	uintptr(rcRangeChars),
	uintptr(rpRangeProperties),
	uintptr(cRanges),
	uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(pwcChars))),
	uintptr(pwLogClust),
	uintptr(pCharProps),
	uintptr(cChars),
	uintptr(pwGlyphs),
	uintptr(pGlyphProps),
	uintptr(cGlyphs),
	uintptr(piAdvance),
	uintptr(pGoffset),
	uintptr(pABC),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // HRESULT
function ScriptPlaceOpenType(
  hdc: THandle;   // HDC optional
  psc: Pointer;   // void** in/out
  psa: Pointer;   // SCRIPT_ANALYSIS* in/out
  tagScript: DWORD;   // DWORD
  tagLangSys: DWORD;   // DWORD
  rcRangeChars: Pointer;   // INT* optional
  rpRangeProperties: Pointer;   // TEXTRANGE_PROPERTIES** optional
  cRanges: Integer;   // INT
  pwcChars: PWideChar;   // LPCWSTR
  pwLogClust: Pointer;   // WORD*
  pCharProps: Pointer;   // SCRIPT_CHARPROP*
  cChars: Integer;   // INT
  pwGlyphs: Pointer;   // WORD*
  pGlyphProps: Pointer;   // SCRIPT_GLYPHPROP*
  cGlyphs: Integer;   // INT
  piAdvance: Pointer;   // INT* out
  pGoffset: Pointer;   // GOFFSET* out
  pABC: Pointer   // ABC* optional, out
): Integer; stdcall;
  external 'USP10.dll' name 'ScriptPlaceOpenType';
result := DllCall("USP10\ScriptPlaceOpenType"
    , "Ptr", hdc   ; HDC optional
    , "Ptr", psc   ; void** in/out
    , "Ptr", psa   ; SCRIPT_ANALYSIS* in/out
    , "UInt", tagScript   ; DWORD
    , "UInt", tagLangSys   ; DWORD
    , "Ptr", rcRangeChars   ; INT* optional
    , "Ptr", rpRangeProperties   ; TEXTRANGE_PROPERTIES** optional
    , "Int", cRanges   ; INT
    , "WStr", pwcChars   ; LPCWSTR
    , "Ptr", pwLogClust   ; WORD*
    , "Ptr", pCharProps   ; SCRIPT_CHARPROP*
    , "Int", cChars   ; INT
    , "Ptr", pwGlyphs   ; WORD*
    , "Ptr", pGlyphProps   ; SCRIPT_GLYPHPROP*
    , "Int", cGlyphs   ; INT
    , "Ptr", piAdvance   ; INT* out
    , "Ptr", pGoffset   ; GOFFSET* out
    , "Ptr", pABC   ; ABC* optional, out
    , "Int")   ; return: HRESULT
●ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC) = DLL("USP10.dll", "int ScriptPlaceOpenType(void*, void*, void*, dword, dword, void*, void*, int, char*, void*, void*, int, void*, void*, int, void*, void*, void*)")
# 呼び出し: ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
# hdc : HDC optional -> "void*"
# psc : void** in/out -> "void*"
# psa : SCRIPT_ANALYSIS* in/out -> "void*"
# tagScript : DWORD -> "dword"
# tagLangSys : DWORD -> "dword"
# rcRangeChars : INT* optional -> "void*"
# rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> "void*"
# cRanges : INT -> "int"
# pwcChars : LPCWSTR -> "char*"
# pwLogClust : WORD* -> "void*"
# pCharProps : SCRIPT_CHARPROP* -> "void*"
# cChars : INT -> "int"
# pwGlyphs : WORD* -> "void*"
# pGlyphProps : SCRIPT_GLYPHPROP* -> "void*"
# cGlyphs : INT -> "int"
# piAdvance : INT* out -> "void*"
# pGoffset : GOFFSET* out -> "void*"
# pABC : ABC* optional, out -> "void*"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。
const std = @import("std");

extern "usp10" fn ScriptPlaceOpenType(
    hdc: ?*anyopaque, // HDC optional
    psc: ?*anyopaque, // void** in/out
    psa: [*c]SCRIPT_ANALYSIS, // SCRIPT_ANALYSIS* in/out
    tagScript: u32, // DWORD
    tagLangSys: u32, // DWORD
    rcRangeChars: [*c]i32, // INT* optional
    rpRangeProperties: [*c][*c]TEXTRANGE_PROPERTIES, // TEXTRANGE_PROPERTIES** optional
    cRanges: i32, // INT
    pwcChars: [*c]const u16, // LPCWSTR
    pwLogClust: [*c]u16, // WORD*
    pCharProps: [*c]SCRIPT_CHARPROP, // SCRIPT_CHARPROP*
    cChars: i32, // INT
    pwGlyphs: [*c]u16, // WORD*
    pGlyphProps: [*c]SCRIPT_GLYPHPROP, // SCRIPT_GLYPHPROP*
    cGlyphs: i32, // INT
    piAdvance: [*c]i32, // INT* out
    pGoffset: [*c]GOFFSET, // GOFFSET* out
    pABC: [*c]ABC // ABC* optional, out
) callconv(std.os.windows.WINAPI) i32;
proc ScriptPlaceOpenType(
    hdc: pointer,  # HDC optional
    psc: pointer,  # void** in/out
    psa: ptr SCRIPT_ANALYSIS,  # SCRIPT_ANALYSIS* in/out
    tagScript: uint32,  # DWORD
    tagLangSys: uint32,  # DWORD
    rcRangeChars: ptr int32,  # INT* optional
    rpRangeProperties: ptr TEXTRANGE_PROPERTIES,  # TEXTRANGE_PROPERTIES** optional
    cRanges: int32,  # INT
    pwcChars: WideCString,  # LPCWSTR
    pwLogClust: ptr uint16,  # WORD*
    pCharProps: ptr SCRIPT_CHARPROP,  # SCRIPT_CHARPROP*
    cChars: int32,  # INT
    pwGlyphs: ptr uint16,  # WORD*
    pGlyphProps: ptr SCRIPT_GLYPHPROP,  # SCRIPT_GLYPHPROP*
    cGlyphs: int32,  # INT
    piAdvance: ptr int32,  # INT* out
    pGoffset: ptr GOFFSET,  # GOFFSET* out
    pABC: ptr ABC  # ABC* optional, out
): int32 {.importc: "ScriptPlaceOpenType", stdcall, dynlib: "USP10.dll".}
pragma(lib, "usp10");
extern(Windows)
int ScriptPlaceOpenType(
    void* hdc,   // HDC optional
    void** psc,   // void** in/out
    SCRIPT_ANALYSIS* psa,   // SCRIPT_ANALYSIS* in/out
    uint tagScript,   // DWORD
    uint tagLangSys,   // DWORD
    int* rcRangeChars,   // INT* optional
    TEXTRANGE_PROPERTIES** rpRangeProperties,   // TEXTRANGE_PROPERTIES** optional
    int cRanges,   // INT
    const(wchar)* pwcChars,   // LPCWSTR
    ushort* pwLogClust,   // WORD*
    SCRIPT_CHARPROP* pCharProps,   // SCRIPT_CHARPROP*
    int cChars,   // INT
    ushort* pwGlyphs,   // WORD*
    SCRIPT_GLYPHPROP* pGlyphProps,   // SCRIPT_GLYPHPROP*
    int cGlyphs,   // INT
    int* piAdvance,   // INT* out
    GOFFSET* pGoffset,   // GOFFSET* out
    ABC* pABC   // ABC* optional, out
);
ccall((:ScriptPlaceOpenType, "USP10.dll"), stdcall, Int32,
      (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCRIPT_ANALYSIS}, UInt32, UInt32, Ptr{Int32}, Ptr{TEXTRANGE_PROPERTIES}, Int32, Cwstring, Ptr{UInt16}, Ptr{SCRIPT_CHARPROP}, Int32, Ptr{UInt16}, Ptr{SCRIPT_GLYPHPROP}, Int32, Ptr{Int32}, Ptr{GOFFSET}, Ptr{ABC}),
      hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
# hdc : HDC optional -> Ptr{Cvoid}
# psc : void** in/out -> Ptr{Cvoid}
# psa : SCRIPT_ANALYSIS* in/out -> Ptr{SCRIPT_ANALYSIS}
# tagScript : DWORD -> UInt32
# tagLangSys : DWORD -> UInt32
# rcRangeChars : INT* optional -> Ptr{Int32}
# rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> Ptr{TEXTRANGE_PROPERTIES}
# cRanges : INT -> Int32
# pwcChars : LPCWSTR -> Cwstring
# pwLogClust : WORD* -> Ptr{UInt16}
# pCharProps : SCRIPT_CHARPROP* -> Ptr{SCRIPT_CHARPROP}
# cChars : INT -> Int32
# pwGlyphs : WORD* -> Ptr{UInt16}
# pGlyphProps : SCRIPT_GLYPHPROP* -> Ptr{SCRIPT_GLYPHPROP}
# cGlyphs : INT -> Int32
# piAdvance : INT* out -> Ptr{Int32}
# pGoffset : GOFFSET* out -> Ptr{GOFFSET}
# pABC : ABC* optional, out -> Ptr{ABC}
# stdcall は 32bit のみ意味を持つ(x64 では無視)。
local ffi = require("ffi")
ffi.cdef[[
int32_t ScriptPlaceOpenType(
    void* hdc,
    void** psc,
    void* psa,
    uint32_t tagScript,
    uint32_t tagLangSys,
    int32_t* rcRangeChars,
    void* rpRangeProperties,
    int32_t cRanges,
    const uint16_t* pwcChars,
    uint16_t* pwLogClust,
    void* pCharProps,
    int32_t cChars,
    uint16_t* pwGlyphs,
    void* pGlyphProps,
    int32_t cGlyphs,
    int32_t* piAdvance,
    void* pGoffset,
    void* pABC);
]]
local usp10 = ffi.load("usp10")
-- usp10.ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
-- hdc : HDC optional
-- psc : void** in/out
-- psa : SCRIPT_ANALYSIS* in/out
-- tagScript : DWORD
-- tagLangSys : DWORD
-- rcRangeChars : INT* optional
-- rpRangeProperties : TEXTRANGE_PROPERTIES** optional
-- cRanges : INT
-- pwcChars : LPCWSTR
-- pwLogClust : WORD*
-- pCharProps : SCRIPT_CHARPROP*
-- cChars : INT
-- pwGlyphs : WORD*
-- pGlyphProps : SCRIPT_GLYPHPROP*
-- cGlyphs : INT
-- piAdvance : INT* out
-- pGoffset : GOFFSET* out
-- pABC : ABC* optional, out
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
const koffi = require('koffi');
const lib = koffi.load('USP10.dll');
const ScriptPlaceOpenType = lib.func('__stdcall', 'ScriptPlaceOpenType', 'int32_t', ['void *', 'void *', 'void *', 'uint32_t', 'uint32_t', 'int32_t *', 'void *', 'int32_t', 'str16', 'uint16_t *', 'void *', 'int32_t', 'uint16_t *', 'void *', 'int32_t', 'int32_t *', 'void *', 'void *']);
// ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
// hdc : HDC optional -> 'void *'
// psc : void** in/out -> 'void *'
// psa : SCRIPT_ANALYSIS* in/out -> 'void *'
// tagScript : DWORD -> 'uint32_t'
// tagLangSys : DWORD -> 'uint32_t'
// rcRangeChars : INT* optional -> 'int32_t *'
// rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> 'void *'
// cRanges : INT -> 'int32_t'
// pwcChars : LPCWSTR -> 'str16'
// pwLogClust : WORD* -> 'uint16_t *'
// pCharProps : SCRIPT_CHARPROP* -> 'void *'
// cChars : INT -> 'int32_t'
// pwGlyphs : WORD* -> 'uint16_t *'
// pGlyphProps : SCRIPT_GLYPHPROP* -> 'void *'
// cGlyphs : INT -> 'int32_t'
// piAdvance : INT* out -> 'int32_t *'
// pGoffset : GOFFSET* out -> 'void *'
// pABC : ABC* optional, out -> 'void *'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
const lib = Deno.dlopen("USP10.dll", {
  ScriptPlaceOpenType: { parameters: ["pointer", "pointer", "pointer", "u32", "u32", "pointer", "pointer", "i32", "buffer", "pointer", "pointer", "i32", "pointer", "pointer", "i32", "pointer", "pointer", "pointer"], result: "i32" },
});
// lib.symbols.ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC)
// hdc : HDC optional -> "pointer"
// psc : void** in/out -> "pointer"
// psa : SCRIPT_ANALYSIS* in/out -> "pointer"
// tagScript : DWORD -> "u32"
// tagLangSys : DWORD -> "u32"
// rcRangeChars : INT* optional -> "pointer"
// rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> "pointer"
// cRanges : INT -> "i32"
// pwcChars : LPCWSTR -> "buffer"
// pwLogClust : WORD* -> "pointer"
// pCharProps : SCRIPT_CHARPROP* -> "pointer"
// cChars : INT -> "i32"
// pwGlyphs : WORD* -> "pointer"
// pGlyphProps : SCRIPT_GLYPHPROP* -> "pointer"
// cGlyphs : INT -> "i32"
// piAdvance : INT* out -> "pointer"
// pGoffset : GOFFSET* out -> "pointer"
// pABC : ABC* optional, out -> "pointer"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。
<?php
$ffi = FFI::cdef(<<<C
int32_t ScriptPlaceOpenType(
    void* hdc,
    void** psc,
    void* psa,
    uint32_t tagScript,
    uint32_t tagLangSys,
    int32_t* rcRangeChars,
    void* rpRangeProperties,
    int32_t cRanges,
    const uint16_t* pwcChars,
    uint16_t* pwLogClust,
    void* pCharProps,
    int32_t cChars,
    uint16_t* pwGlyphs,
    void* pGlyphProps,
    int32_t cGlyphs,
    int32_t* piAdvance,
    void* pGoffset,
    void* pABC);
C, "USP10.dll");
// $ffi->ScriptPlaceOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance, pGoffset, pABC);
// hdc : HDC optional
// psc : void** in/out
// psa : SCRIPT_ANALYSIS* in/out
// tagScript : DWORD
// tagLangSys : DWORD
// rcRangeChars : INT* optional
// rpRangeProperties : TEXTRANGE_PROPERTIES** optional
// cRanges : INT
// pwcChars : LPCWSTR
// pwLogClust : WORD*
// pCharProps : SCRIPT_CHARPROP*
// cChars : INT
// pwGlyphs : WORD*
// pGlyphProps : SCRIPT_GLYPHPROP*
// cGlyphs : INT
// piAdvance : INT* out
// pGoffset : GOFFSET* out
// pABC : ABC* optional, out
// 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
// WINAPI(stdcall): x64 では呼出規約が統一されるため問題なし。x86 では __stdcall 対応のラッパが必要な場合あり。
import com.sun.jna.*;
import com.sun.jna.ptr.*;
import com.sun.jna.win32.StdCallLibrary;
import com.sun.jna.win32.W32APIOptions;

public interface Usp10 extends StdCallLibrary {
    Usp10 INSTANCE = Native.load("usp10", Usp10.class);
    int ScriptPlaceOpenType(
        Pointer hdc,   // HDC optional
        Pointer psc,   // void** in/out
        Pointer psa,   // SCRIPT_ANALYSIS* in/out
        int tagScript,   // DWORD
        int tagLangSys,   // DWORD
        IntByReference rcRangeChars,   // INT* optional
        Pointer rpRangeProperties,   // TEXTRANGE_PROPERTIES** optional
        int cRanges,   // INT
        WString pwcChars,   // LPCWSTR
        ShortByReference pwLogClust,   // WORD*
        Pointer pCharProps,   // SCRIPT_CHARPROP*
        int cChars,   // INT
        ShortByReference pwGlyphs,   // WORD*
        Pointer pGlyphProps,   // SCRIPT_GLYPHPROP*
        int cGlyphs,   // INT
        IntByReference piAdvance,   // INT* out
        Pointer pGoffset,   // GOFFSET* out
        Pointer pABC   // ABC* optional, out
    );
}
@[Link("usp10")]
lib LibUSP10
  fun ScriptPlaceOpenType = ScriptPlaceOpenType(
    hdc : Void*,   # HDC optional
    psc : Void**,   # void** in/out
    psa : SCRIPT_ANALYSIS*,   # SCRIPT_ANALYSIS* in/out
    tagScript : UInt32,   # DWORD
    tagLangSys : UInt32,   # DWORD
    rcRangeChars : Int32*,   # INT* optional
    rpRangeProperties : TEXTRANGE_PROPERTIES**,   # TEXTRANGE_PROPERTIES** optional
    cRanges : Int32,   # INT
    pwcChars : UInt16*,   # LPCWSTR
    pwLogClust : UInt16*,   # WORD*
    pCharProps : SCRIPT_CHARPROP*,   # SCRIPT_CHARPROP*
    cChars : Int32,   # INT
    pwGlyphs : UInt16*,   # WORD*
    pGlyphProps : SCRIPT_GLYPHPROP*,   # SCRIPT_GLYPHPROP*
    cGlyphs : Int32,   # INT
    piAdvance : Int32*,   # INT* out
    pGoffset : GOFFSET*,   # GOFFSET* out
    pABC : ABC*   # ABC* optional, out
  ) : Int32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。
import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef ScriptPlaceOpenTypeNative = Int32 Function(Pointer<Void>, Pointer<Void>, Pointer<Void>, Uint32, Uint32, Pointer<Int32>, Pointer<Void>, Int32, Pointer<Utf16>, Pointer<Uint16>, Pointer<Void>, Int32, Pointer<Uint16>, Pointer<Void>, Int32, Pointer<Int32>, Pointer<Void>, Pointer<Void>);
typedef ScriptPlaceOpenTypeDart = int Function(Pointer<Void>, Pointer<Void>, Pointer<Void>, int, int, Pointer<Int32>, Pointer<Void>, int, Pointer<Utf16>, Pointer<Uint16>, Pointer<Void>, int, Pointer<Uint16>, Pointer<Void>, int, Pointer<Int32>, Pointer<Void>, Pointer<Void>);
final ScriptPlaceOpenType = DynamicLibrary.open('USP10.dll')
    .lookupFunction<ScriptPlaceOpenTypeNative, ScriptPlaceOpenTypeDart>('ScriptPlaceOpenType');
// hdc : HDC optional -> Pointer<Void>
// psc : void** in/out -> Pointer<Void>
// psa : SCRIPT_ANALYSIS* in/out -> Pointer<Void>
// tagScript : DWORD -> Uint32
// tagLangSys : DWORD -> Uint32
// rcRangeChars : INT* optional -> Pointer<Int32>
// rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> Pointer<Void>
// cRanges : INT -> Int32
// pwcChars : LPCWSTR -> Pointer<Utf16>
// pwLogClust : WORD* -> Pointer<Uint16>
// pCharProps : SCRIPT_CHARPROP* -> Pointer<Void>
// cChars : INT -> Int32
// pwGlyphs : WORD* -> Pointer<Uint16>
// pGlyphProps : SCRIPT_GLYPHPROP* -> Pointer<Void>
// cGlyphs : INT -> Int32
// piAdvance : INT* out -> Pointer<Int32>
// pGoffset : GOFFSET* out -> Pointer<Void>
// pABC : ABC* optional, out -> Pointer<Void>
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。
{$mode objfpc}{$H+}
function ScriptPlaceOpenType(
  hdc: THandle;   // HDC optional
  psc: Pointer;   // void** in/out
  psa: Pointer;   // SCRIPT_ANALYSIS* in/out
  tagScript: DWORD;   // DWORD
  tagLangSys: DWORD;   // DWORD
  rcRangeChars: Pointer;   // INT* optional
  rpRangeProperties: Pointer;   // TEXTRANGE_PROPERTIES** optional
  cRanges: Integer;   // INT
  pwcChars: PWideChar;   // LPCWSTR
  pwLogClust: Pointer;   // WORD*
  pCharProps: Pointer;   // SCRIPT_CHARPROP*
  cChars: Integer;   // INT
  pwGlyphs: Pointer;   // WORD*
  pGlyphProps: Pointer;   // SCRIPT_GLYPHPROP*
  cGlyphs: Integer;   // INT
  piAdvance: Pointer;   // INT* out
  pGoffset: Pointer;   // GOFFSET* out
  pABC: Pointer   // ABC* optional, out
): Integer; stdcall;
  external 'USP10.dll' name 'ScriptPlaceOpenType';
import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "ScriptPlaceOpenType"
  c_ScriptPlaceOpenType :: Ptr () -> Ptr () -> Ptr () -> Word32 -> Word32 -> Ptr Int32 -> Ptr () -> Int32 -> CWString -> Ptr Word16 -> Ptr () -> Int32 -> Ptr Word16 -> Ptr () -> Int32 -> Ptr Int32 -> Ptr () -> Ptr () -> IO Int32
-- hdc : HDC optional -> Ptr ()
-- psc : void** in/out -> Ptr ()
-- psa : SCRIPT_ANALYSIS* in/out -> Ptr ()
-- tagScript : DWORD -> Word32
-- tagLangSys : DWORD -> Word32
-- rcRangeChars : INT* optional -> Ptr Int32
-- rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> Ptr ()
-- cRanges : INT -> Int32
-- pwcChars : LPCWSTR -> CWString
-- pwLogClust : WORD* -> Ptr Word16
-- pCharProps : SCRIPT_CHARPROP* -> Ptr ()
-- cChars : INT -> Int32
-- pwGlyphs : WORD* -> Ptr Word16
-- pGlyphProps : SCRIPT_GLYPHPROP* -> Ptr ()
-- cGlyphs : INT -> Int32
-- piAdvance : INT* out -> Ptr Int32
-- pGoffset : GOFFSET* out -> Ptr ()
-- pABC : ABC* optional, out -> Ptr ()
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。
open Ctypes
open Foreign

let scriptplaceopentype =
  foreign "ScriptPlaceOpenType"
    ((ptr void) @-> (ptr void) @-> (ptr void) @-> uint32_t @-> uint32_t @-> (ptr int32_t) @-> (ptr void) @-> int32_t @-> (ptr uint16_t) @-> (ptr uint16_t) @-> (ptr void) @-> int32_t @-> (ptr uint16_t) @-> (ptr void) @-> int32_t @-> (ptr int32_t) @-> (ptr void) @-> (ptr void) @-> returning int32_t)
(* hdc : HDC optional -> (ptr void) *)
(* psc : void** in/out -> (ptr void) *)
(* psa : SCRIPT_ANALYSIS* in/out -> (ptr void) *)
(* tagScript : DWORD -> uint32_t *)
(* tagLangSys : DWORD -> uint32_t *)
(* rcRangeChars : INT* optional -> (ptr int32_t) *)
(* rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> (ptr void) *)
(* cRanges : INT -> int32_t *)
(* pwcChars : LPCWSTR -> (ptr uint16_t) *)
(* pwLogClust : WORD* -> (ptr uint16_t) *)
(* pCharProps : SCRIPT_CHARPROP* -> (ptr void) *)
(* cChars : INT -> int32_t *)
(* pwGlyphs : WORD* -> (ptr uint16_t) *)
(* pGlyphProps : SCRIPT_GLYPHPROP* -> (ptr void) *)
(* cGlyphs : INT -> int32_t *)
(* piAdvance : INT* out -> (ptr int32_t) *)
(* pGoffset : GOFFSET* out -> (ptr void) *)
(* pABC : ABC* optional, out -> (ptr void) *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)
(cffi:define-foreign-library usp10 (t "USP10.dll"))
(cffi:use-foreign-library usp10)

(cffi:defcfun ("ScriptPlaceOpenType" script-place-open-type :convention :stdcall) :int32
  (hdc :pointer)   ; HDC optional
  (psc :pointer)   ; void** in/out
  (psa :pointer)   ; SCRIPT_ANALYSIS* in/out
  (tag-script :uint32)   ; DWORD
  (tag-lang-sys :uint32)   ; DWORD
  (rc-range-chars :pointer)   ; INT* optional
  (rp-range-properties :pointer)   ; TEXTRANGE_PROPERTIES** optional
  (c-ranges :int32)   ; INT
  (pwc-chars (:string :encoding :utf-16le))   ; LPCWSTR
  (pw-log-clust :pointer)   ; WORD*
  (p-char-props :pointer)   ; SCRIPT_CHARPROP*
  (c-chars :int32)   ; INT
  (pw-glyphs :pointer)   ; WORD*
  (p-glyph-props :pointer)   ; SCRIPT_GLYPHPROP*
  (c-glyphs :int32)   ; INT
  (pi-advance :pointer)   ; INT* out
  (p-goffset :pointer)   ; GOFFSET* out
  (p-abc :pointer))   ; ABC* optional, out
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。
use Win32::API;
my $ScriptPlaceOpenType = Win32::API::More->new('USP10',
    'int ScriptPlaceOpenType(HANDLE hdc, LPVOID psc, LPVOID psa, DWORD tagScript, DWORD tagLangSys, LPVOID rcRangeChars, LPVOID rpRangeProperties, int cRanges, LPCWSTR pwcChars, LPVOID pwLogClust, LPVOID pCharProps, int cChars, LPVOID pwGlyphs, LPVOID pGlyphProps, int cGlyphs, LPVOID piAdvance, LPVOID pGoffset, LPVOID pABC)');
# my $ret = $ScriptPlaceOpenType->Call($hdc, $psc, $psa, $tagScript, $tagLangSys, $rcRangeChars, $rpRangeProperties, $cRanges, $pwcChars, $pwLogClust, $pCharProps, $cChars, $pwGlyphs, $pGlyphProps, $cGlyphs, $piAdvance, $pGoffset, $pABC);
# hdc : HDC optional -> HANDLE
# psc : void** in/out -> LPVOID
# psa : SCRIPT_ANALYSIS* in/out -> LPVOID
# tagScript : DWORD -> DWORD
# tagLangSys : DWORD -> DWORD
# rcRangeChars : INT* optional -> LPVOID
# rpRangeProperties : TEXTRANGE_PROPERTIES** optional -> LPVOID
# cRanges : INT -> int
# pwcChars : LPCWSTR -> LPCWSTR
# pwLogClust : WORD* -> LPVOID
# pCharProps : SCRIPT_CHARPROP* -> LPVOID
# cChars : INT -> int
# pwGlyphs : WORD* -> LPVOID
# pGlyphProps : SCRIPT_GLYPHPROP* -> LPVOID
# cGlyphs : INT -> int
# piAdvance : INT* out -> LPVOID
# pGoffset : GOFFSET* out -> LPVOID
# pABC : ABC* optional, out -> LPVOID
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。

関連項目

公式の関連項目
使用する型