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

ScriptShapeOpenType

関数
OpenType機能を用いて文字列をグリフ列に整形する。
DLLUSP10.dll呼出規約winapi対応OSWindows Vista 以降
📘 Microsoft Learn (日本語) · English

シグネチャ

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

HRESULT ScriptShapeOpenType(
    HDC hdc,   // optional
    void** psc,
    SCRIPT_ANALYSIS* psa,
    DWORD tagScript,
    DWORD tagLangSys,
    INT* rcRangeChars,   // optional
    TEXTRANGE_PROPERTIES** rpRangeProperties,   // optional
    INT cRanges,
    LPCWSTR pwcChars,
    INT cChars,
    INT cMaxGlyphs,
    WORD* pwLogClust,
    SCRIPT_CHARPROP* pCharProps,
    WORD* pwOutGlyphs,
    SCRIPT_GLYPHPROP* pOutGlyphProps,
    INT* pcGlyphs
);

パラメーター

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

以前の ScriptItemizeOpenType の呼び出しで取得した SCRIPT_ANALYSIS 構造体へのポインター。この構造体はシェーピングエンジンを識別し、グリフを正しく形成できるようにします。

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

tagScriptDWORDin表記体系の OpenType スクリプトタグを定義する OPENTYPE_TAG 構造体。
tagLangSysDWORDin表記体系の OpenType 言語タグを含む OPENTYPE_TAG 構造体。
rcRangeCharsINT*inoptional各範囲 (range) 内の文字数の配列。配列要素の数は cRanges で示されます。この配列の要素の値の合計は cChars の値に等しくなります。
rpRangePropertiesTEXTRANGE_PROPERTIES**inoptionalTEXTRANGE_PROPERTIES 構造体の配列で、各構造体は 1 つの OpenType 機能範囲を表します。構造体の数は cRanges パラメーターで示されます。rpRangeProperties の詳細については、「解説」セクションを参照してください。
cRangesINTinOpenType 機能範囲の数。
pwcCharsLPCWSTRinランを構成する Unicode 文字の配列へのポインター。
cCharsINTinUnicode ラン内の文字数。
cMaxGlyphsINTin生成するグリフの最大数。
pwLogClustWORD*outこの関数が論理クラスター (cluster) 情報の配列を取得するバッファーへのポインター。各配列要素は Unicode 文字配列内の 1 文字に対応します。各要素の値は、ラン内の先頭グリフから、対応する文字を含むクラスターの先頭グリフまでのオフセットです。SCRIPT_ANALYSIS 構造体の fRTL メンバーが TRUE の場合、配列を読み進めるにつれて要素の値は減少することに注意してください。
pCharPropsSCRIPT_CHARPROP*outこの関数が文字プロパティ値の配列を取得するバッファーへのポインター。長さは cChars で示されます。
pwOutGlyphsWORD*outこの関数がグリフの配列を取得するバッファーへのポインター。
pOutGlyphPropsSCRIPT_GLYPHPROP*outこの関数が、取得した各グリフの属性の配列を取得するバッファーへのポインター。値の長さは pcGlyphs の値に等しくなります。グリフ 1 つにつき 1 つのグリフプロパティが示されるため、このパラメーターの値は cMaxGlyphs で指定される要素数を示します。
pcGlyphsINT*outこの関数が、pwOutGlyphs に示されるグリフ数を取得する場所へのポインター。

戻り値の型: HRESULT

公式ドキュメント

OpenType 情報を用いて、Unicode ランに対するグリフと表示属性を生成します。各ランは、この関数の 1 回の呼び出しで構成されます。

戻り値

成功した場合は 0 を返します。成功しなかった場合、関数は 0 以外の HRESULT 値を返します。すべてのエラーの場合、すべての出力配列値の内容は未定義です。

エラーの戻り値には次のものが含まれます。

解説(Remarks)

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

この関数が E_OUTOFMEMORY を返した場合、アプリケーションは、十分な大きさのバッファーが提供されるまで、出力バッファーを順次大きくしながら ScriptShapeOpenType を繰り返し呼び出すことができます。コードポイントによって生成されるグリフの数は、スクリプトとフォントによって異なります。単純なスクリプトでは、1 つの Unicode コードポイントが 1 つのグリフを生成する場合があります。しかし、複雑なスクリプトのフォントは、複数の構成要素から文字を構築するため、文字数の数倍ものグリフを生成する場合があります。また、無効な文字表現など、無効なシーケンスを表すために余分なグリフが追加される特殊なケースもあります。したがって、pwOutGlyphs で示されるバッファーのサイズの妥当な見積もりは、文字バッファーの長さの 1.5 倍に、無効なシーケンス表現などのまれなケースに備えて 16 グリフを追加した値です。

フォントまたはオペレーティングシステムがグリフインデックスをサポートできない場合、この関数は SCRIPT_ANALYSIS 構造体の fNoGlyphIndex メンバーを設定することがあります。

アプリケーションは、フォントが特定の文字列内の文字をサポートしているかどうかを判定するために ScriptShapeOpenType を呼び出すことができます。関数が S_OK を返した場合、アプリケーションは出力に欠落グリフがないか確認してください。SCRIPT_ANALYSIS 構造体で fLogicalOrder が TRUE に設定されている場合、関数は常に元の Unicode 文字と同じ順序でグリフを生成します。fLogicalOrder が FALSE に設定されている場合、ScriptTextOut が ExtTextOut を呼び出す前にグリフを反転させる必要がないように、関数は右から左へのアイテムを逆順で生成します。

SCRIPT_ANALYSIS の eScript メンバーが SCRIPT_UNDEFINED に設定されている場合、シェーピングは無効になります。この場合、ScriptShapeOpenType はフォントの cmap テーブルにあるグリフを表示します。テーブルにグリフがない場合、関数はグリフが欠落していることを示します。

ScriptShapeOpenType は、ラン内でクラスターを一様に順序付けし、クラスター内でグリフを一様に順序付けします。順序付けが左から右か右から左かを識別するために、ScriptItemizeOpenType から得られる SCRIPT_ANALYSIS の fRTL メンバーの値を使用します。

rpRangeProperties パラメーターについて、TEXTRANGE_PROPERTIES 構造体は OPENTYPE_FEATURE_RECORD 構造体の配列を指します。この配列は次のように使用されます。

Illustration showing the range, item, run, and feature of each word in a line of text that uses six properties to present eight words
注意 この図では、ScriptShapeOpenType への多数の呼び出しが使用されており、それぞれが 1 つのランを表しています。
重要 Windows 8 以降: Windows 7 での実行を維持するために、Uniscribe を使用するモジュールは、ライブラリリスト内で gdi32.lib より前に Usp10.lib を指定する必要があります。

例

次の例は、ScriptShapeOpenType が文字配列 (pwcChars) とグリフ配列 (pwOutGlyphs) から論理クラスター配列 (pwLogClust) をどのように生成するかを示しています。このランには 4 つのクラスターがあります。

このランは、文字配列とグリフ配列で次のように記述されます。

文字配列:

グリフ配列: 配列要素の表記は次の項目で構成されます。 生成されるクラスター配列には、文字を含むクラスターへのオフセットが格納されます。単位はグリフで表されます。
出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での呼び出し定義

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

HRESULT ScriptShapeOpenType(
    HDC hdc,   // optional
    void** psc,
    SCRIPT_ANALYSIS* psa,
    DWORD tagScript,
    DWORD tagLangSys,
    INT* rcRangeChars,   // optional
    TEXTRANGE_PROPERTIES** rpRangeProperties,   // optional
    INT cRanges,
    LPCWSTR pwcChars,
    INT cChars,
    INT cMaxGlyphs,
    WORD* pwLogClust,
    SCRIPT_CHARPROP* pCharProps,
    WORD* pwOutGlyphs,
    SCRIPT_GLYPHPROP* pOutGlyphProps,
    INT* pcGlyphs
);
[DllImport("USP10.dll", ExactSpelling = true)]
static extern int ScriptShapeOpenType(
    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
    int cChars,   // INT
    int cMaxGlyphs,   // INT
    out ushort pwLogClust,   // WORD* out
    IntPtr pCharProps,   // SCRIPT_CHARPROP* out
    out ushort pwOutGlyphs,   // WORD* out
    IntPtr pOutGlyphProps,   // SCRIPT_GLYPHPROP* out
    out int pcGlyphs   // INT* out
);
<DllImport("USP10.dll", ExactSpelling:=True)>
Public Shared Function ScriptShapeOpenType(
    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
    cChars As Integer,   ' INT
    cMaxGlyphs As Integer,   ' INT
    <Out> ByRef pwLogClust As UShort,   ' WORD* out
    pCharProps As IntPtr,   ' SCRIPT_CHARPROP* out
    <Out> ByRef pwOutGlyphs As UShort,   ' WORD* out
    pOutGlyphProps As IntPtr,   ' SCRIPT_GLYPHPROP* out
    <Out> ByRef pcGlyphs As Integer   ' INT* 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
' cChars : INT
' cMaxGlyphs : INT
' pwLogClust : WORD* out
' pCharProps : SCRIPT_CHARPROP* out
' pwOutGlyphs : WORD* out
' pOutGlyphProps : SCRIPT_GLYPHPROP* out
' pcGlyphs : INT* out
Declare PtrSafe Function ScriptShapeOpenType 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, _
    ByVal cChars As Long, _
    ByVal cMaxGlyphs As Long, _
    ByRef pwLogClust As Integer, _
    ByVal pCharProps As LongPtr, _
    ByRef pwOutGlyphs As Integer, _
    ByVal pOutGlyphProps As LongPtr, _
    ByRef pcGlyphs As Long) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。
import ctypes
from ctypes import wintypes

ScriptShapeOpenType = ctypes.windll.usp10.ScriptShapeOpenType
ScriptShapeOpenType.restype = ctypes.c_int
ScriptShapeOpenType.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.c_int,  # cChars : INT
    ctypes.c_int,  # cMaxGlyphs : INT
    ctypes.POINTER(ctypes.c_ushort),  # pwLogClust : WORD* out
    ctypes.c_void_p,  # pCharProps : SCRIPT_CHARPROP* out
    ctypes.POINTER(ctypes.c_ushort),  # pwOutGlyphs : WORD* out
    ctypes.c_void_p,  # pOutGlyphProps : SCRIPT_GLYPHPROP* out
    ctypes.POINTER(ctypes.c_int),  # pcGlyphs : INT* out
]
require 'fiddle'
require 'fiddle/import'

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

var (
	usp10 = windows.NewLazySystemDLL("USP10.dll")
	procScriptShapeOpenType = usp10.NewProc("ScriptShapeOpenType")
)

// 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), cChars (INT), cMaxGlyphs (INT), pwLogClust (WORD* out), pCharProps (SCRIPT_CHARPROP* out), pwOutGlyphs (WORD* out), pOutGlyphProps (SCRIPT_GLYPHPROP* out), pcGlyphs (INT* out)
r1, _, err := procScriptShapeOpenType.Call(
	uintptr(hdc),
	uintptr(psc),
	uintptr(psa),
	uintptr(tagScript),
	uintptr(tagLangSys),
	uintptr(rcRangeChars),
	uintptr(rpRangeProperties),
	uintptr(cRanges),
	uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(pwcChars))),
	uintptr(cChars),
	uintptr(cMaxGlyphs),
	uintptr(pwLogClust),
	uintptr(pCharProps),
	uintptr(pwOutGlyphs),
	uintptr(pOutGlyphProps),
	uintptr(pcGlyphs),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // HRESULT
function ScriptShapeOpenType(
  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
  cChars: Integer;   // INT
  cMaxGlyphs: Integer;   // INT
  pwLogClust: Pointer;   // WORD* out
  pCharProps: Pointer;   // SCRIPT_CHARPROP* out
  pwOutGlyphs: Pointer;   // WORD* out
  pOutGlyphProps: Pointer;   // SCRIPT_GLYPHPROP* out
  pcGlyphs: Pointer   // INT* out
): Integer; stdcall;
  external 'USP10.dll' name 'ScriptShapeOpenType';
result := DllCall("USP10\ScriptShapeOpenType"
    , "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
    , "Int", cChars   ; INT
    , "Int", cMaxGlyphs   ; INT
    , "Ptr", pwLogClust   ; WORD* out
    , "Ptr", pCharProps   ; SCRIPT_CHARPROP* out
    , "Ptr", pwOutGlyphs   ; WORD* out
    , "Ptr", pOutGlyphProps   ; SCRIPT_GLYPHPROP* out
    , "Ptr", pcGlyphs   ; INT* out
    , "Int")   ; return: HRESULT
●ScriptShapeOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs) = DLL("USP10.dll", "int ScriptShapeOpenType(void*, void*, void*, dword, dword, void*, void*, int, char*, int, int, void*, void*, void*, void*, void*)")
# 呼び出し: ScriptShapeOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs)
# 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*"
# cChars : INT -> "int"
# cMaxGlyphs : INT -> "int"
# pwLogClust : WORD* out -> "void*"
# pCharProps : SCRIPT_CHARPROP* out -> "void*"
# pwOutGlyphs : WORD* out -> "void*"
# pOutGlyphProps : SCRIPT_GLYPHPROP* out -> "void*"
# pcGlyphs : INT* out -> "void*"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。
const std = @import("std");

extern "usp10" fn ScriptShapeOpenType(
    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
    cChars: i32, // INT
    cMaxGlyphs: i32, // INT
    pwLogClust: [*c]u16, // WORD* out
    pCharProps: [*c]SCRIPT_CHARPROP, // SCRIPT_CHARPROP* out
    pwOutGlyphs: [*c]u16, // WORD* out
    pOutGlyphProps: [*c]SCRIPT_GLYPHPROP, // SCRIPT_GLYPHPROP* out
    pcGlyphs: [*c]i32 // INT* out
) callconv(std.os.windows.WINAPI) i32;
proc ScriptShapeOpenType(
    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
    cChars: int32,  # INT
    cMaxGlyphs: int32,  # INT
    pwLogClust: ptr uint16,  # WORD* out
    pCharProps: ptr SCRIPT_CHARPROP,  # SCRIPT_CHARPROP* out
    pwOutGlyphs: ptr uint16,  # WORD* out
    pOutGlyphProps: ptr SCRIPT_GLYPHPROP,  # SCRIPT_GLYPHPROP* out
    pcGlyphs: ptr int32  # INT* out
): int32 {.importc: "ScriptShapeOpenType", stdcall, dynlib: "USP10.dll".}
pragma(lib, "usp10");
extern(Windows)
int ScriptShapeOpenType(
    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
    int cChars,   // INT
    int cMaxGlyphs,   // INT
    ushort* pwLogClust,   // WORD* out
    SCRIPT_CHARPROP* pCharProps,   // SCRIPT_CHARPROP* out
    ushort* pwOutGlyphs,   // WORD* out
    SCRIPT_GLYPHPROP* pOutGlyphProps,   // SCRIPT_GLYPHPROP* out
    int* pcGlyphs   // INT* out
);
ccall((:ScriptShapeOpenType, "USP10.dll"), stdcall, Int32,
      (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCRIPT_ANALYSIS}, UInt32, UInt32, Ptr{Int32}, Ptr{TEXTRANGE_PROPERTIES}, Int32, Cwstring, Int32, Int32, Ptr{UInt16}, Ptr{SCRIPT_CHARPROP}, Ptr{UInt16}, Ptr{SCRIPT_GLYPHPROP}, Ptr{Int32}),
      hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs)
# 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
# cChars : INT -> Int32
# cMaxGlyphs : INT -> Int32
# pwLogClust : WORD* out -> Ptr{UInt16}
# pCharProps : SCRIPT_CHARPROP* out -> Ptr{SCRIPT_CHARPROP}
# pwOutGlyphs : WORD* out -> Ptr{UInt16}
# pOutGlyphProps : SCRIPT_GLYPHPROP* out -> Ptr{SCRIPT_GLYPHPROP}
# pcGlyphs : INT* out -> Ptr{Int32}
# stdcall は 32bit のみ意味を持つ(x64 では無視)。
local ffi = require("ffi")
ffi.cdef[[
int32_t ScriptShapeOpenType(
    void* hdc,
    void** psc,
    void* psa,
    uint32_t tagScript,
    uint32_t tagLangSys,
    int32_t* rcRangeChars,
    void* rpRangeProperties,
    int32_t cRanges,
    const uint16_t* pwcChars,
    int32_t cChars,
    int32_t cMaxGlyphs,
    uint16_t* pwLogClust,
    void* pCharProps,
    uint16_t* pwOutGlyphs,
    void* pOutGlyphProps,
    int32_t* pcGlyphs);
]]
local usp10 = ffi.load("usp10")
-- usp10.ScriptShapeOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs)
-- 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
-- cChars : INT
-- cMaxGlyphs : INT
-- pwLogClust : WORD* out
-- pCharProps : SCRIPT_CHARPROP* out
-- pwOutGlyphs : WORD* out
-- pOutGlyphProps : SCRIPT_GLYPHPROP* out
-- pcGlyphs : INT* out
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
const koffi = require('koffi');
const lib = koffi.load('USP10.dll');
const ScriptShapeOpenType = lib.func('__stdcall', 'ScriptShapeOpenType', 'int32_t', ['void *', 'void *', 'void *', 'uint32_t', 'uint32_t', 'int32_t *', 'void *', 'int32_t', 'str16', 'int32_t', 'int32_t', 'uint16_t *', 'void *', 'uint16_t *', 'void *', 'int32_t *']);
// ScriptShapeOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs)
// 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'
// cChars : INT -> 'int32_t'
// cMaxGlyphs : INT -> 'int32_t'
// pwLogClust : WORD* out -> 'uint16_t *'
// pCharProps : SCRIPT_CHARPROP* out -> 'void *'
// pwOutGlyphs : WORD* out -> 'uint16_t *'
// pOutGlyphProps : SCRIPT_GLYPHPROP* out -> 'void *'
// pcGlyphs : INT* out -> 'int32_t *'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
const lib = Deno.dlopen("USP10.dll", {
  ScriptShapeOpenType: { parameters: ["pointer", "pointer", "pointer", "u32", "u32", "pointer", "pointer", "i32", "buffer", "i32", "i32", "pointer", "pointer", "pointer", "pointer", "pointer"], result: "i32" },
});
// lib.symbols.ScriptShapeOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs)
// 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"
// cChars : INT -> "i32"
// cMaxGlyphs : INT -> "i32"
// pwLogClust : WORD* out -> "pointer"
// pCharProps : SCRIPT_CHARPROP* out -> "pointer"
// pwOutGlyphs : WORD* out -> "pointer"
// pOutGlyphProps : SCRIPT_GLYPHPROP* out -> "pointer"
// pcGlyphs : INT* out -> "pointer"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。
<?php
$ffi = FFI::cdef(<<<C
int32_t ScriptShapeOpenType(
    void* hdc,
    void** psc,
    void* psa,
    uint32_t tagScript,
    uint32_t tagLangSys,
    int32_t* rcRangeChars,
    void* rpRangeProperties,
    int32_t cRanges,
    const uint16_t* pwcChars,
    int32_t cChars,
    int32_t cMaxGlyphs,
    uint16_t* pwLogClust,
    void* pCharProps,
    uint16_t* pwOutGlyphs,
    void* pOutGlyphProps,
    int32_t* pcGlyphs);
C, "USP10.dll");
// $ffi->ScriptShapeOpenType(hdc, psc, psa, tagScript, tagLangSys, rcRangeChars, rpRangeProperties, cRanges, pwcChars, cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
// 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
// cChars : INT
// cMaxGlyphs : INT
// pwLogClust : WORD* out
// pCharProps : SCRIPT_CHARPROP* out
// pwOutGlyphs : WORD* out
// pOutGlyphProps : SCRIPT_GLYPHPROP* out
// pcGlyphs : INT* 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 ScriptShapeOpenType(
        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
        int cChars,   // INT
        int cMaxGlyphs,   // INT
        ShortByReference pwLogClust,   // WORD* out
        Pointer pCharProps,   // SCRIPT_CHARPROP* out
        ShortByReference pwOutGlyphs,   // WORD* out
        Pointer pOutGlyphProps,   // SCRIPT_GLYPHPROP* out
        IntByReference pcGlyphs   // INT* out
    );
}
@[Link("usp10")]
lib LibUSP10
  fun ScriptShapeOpenType = ScriptShapeOpenType(
    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
    cChars : Int32,   # INT
    cMaxGlyphs : Int32,   # INT
    pwLogClust : UInt16*,   # WORD* out
    pCharProps : SCRIPT_CHARPROP*,   # SCRIPT_CHARPROP* out
    pwOutGlyphs : UInt16*,   # WORD* out
    pOutGlyphProps : SCRIPT_GLYPHPROP*,   # SCRIPT_GLYPHPROP* out
    pcGlyphs : Int32*   # INT* out
  ) : Int32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。
import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef ScriptShapeOpenTypeNative = Int32 Function(Pointer<Void>, Pointer<Void>, Pointer<Void>, Uint32, Uint32, Pointer<Int32>, Pointer<Void>, Int32, Pointer<Utf16>, Int32, Int32, Pointer<Uint16>, Pointer<Void>, Pointer<Uint16>, Pointer<Void>, Pointer<Int32>);
typedef ScriptShapeOpenTypeDart = int Function(Pointer<Void>, Pointer<Void>, Pointer<Void>, int, int, Pointer<Int32>, Pointer<Void>, int, Pointer<Utf16>, int, int, Pointer<Uint16>, Pointer<Void>, Pointer<Uint16>, Pointer<Void>, Pointer<Int32>);
final ScriptShapeOpenType = DynamicLibrary.open('USP10.dll')
    .lookupFunction<ScriptShapeOpenTypeNative, ScriptShapeOpenTypeDart>('ScriptShapeOpenType');
// 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>
// cChars : INT -> Int32
// cMaxGlyphs : INT -> Int32
// pwLogClust : WORD* out -> Pointer<Uint16>
// pCharProps : SCRIPT_CHARPROP* out -> Pointer<Void>
// pwOutGlyphs : WORD* out -> Pointer<Uint16>
// pOutGlyphProps : SCRIPT_GLYPHPROP* out -> Pointer<Void>
// pcGlyphs : INT* out -> Pointer<Int32>
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。
{$mode objfpc}{$H+}
function ScriptShapeOpenType(
  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
  cChars: Integer;   // INT
  cMaxGlyphs: Integer;   // INT
  pwLogClust: Pointer;   // WORD* out
  pCharProps: Pointer;   // SCRIPT_CHARPROP* out
  pwOutGlyphs: Pointer;   // WORD* out
  pOutGlyphProps: Pointer;   // SCRIPT_GLYPHPROP* out
  pcGlyphs: Pointer   // INT* out
): Integer; stdcall;
  external 'USP10.dll' name 'ScriptShapeOpenType';
import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "ScriptShapeOpenType"
  c_ScriptShapeOpenType :: Ptr () -> Ptr () -> Ptr () -> Word32 -> Word32 -> Ptr Int32 -> Ptr () -> Int32 -> CWString -> Int32 -> Int32 -> Ptr Word16 -> Ptr () -> Ptr Word16 -> Ptr () -> Ptr Int32 -> 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
-- cChars : INT -> Int32
-- cMaxGlyphs : INT -> Int32
-- pwLogClust : WORD* out -> Ptr Word16
-- pCharProps : SCRIPT_CHARPROP* out -> Ptr ()
-- pwOutGlyphs : WORD* out -> Ptr Word16
-- pOutGlyphProps : SCRIPT_GLYPHPROP* out -> Ptr ()
-- pcGlyphs : INT* out -> Ptr Int32
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。
open Ctypes
open Foreign

let scriptshapeopentype =
  foreign "ScriptShapeOpenType"
    ((ptr void) @-> (ptr void) @-> (ptr void) @-> uint32_t @-> uint32_t @-> (ptr int32_t) @-> (ptr void) @-> int32_t @-> (ptr uint16_t) @-> int32_t @-> int32_t @-> (ptr uint16_t) @-> (ptr void) @-> (ptr uint16_t) @-> (ptr void) @-> (ptr int32_t) @-> 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) *)
(* cChars : INT -> int32_t *)
(* cMaxGlyphs : INT -> int32_t *)
(* pwLogClust : WORD* out -> (ptr uint16_t) *)
(* pCharProps : SCRIPT_CHARPROP* out -> (ptr void) *)
(* pwOutGlyphs : WORD* out -> (ptr uint16_t) *)
(* pOutGlyphProps : SCRIPT_GLYPHPROP* out -> (ptr void) *)
(* pcGlyphs : INT* out -> (ptr int32_t) *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)
(cffi:define-foreign-library usp10 (t "USP10.dll"))
(cffi:use-foreign-library usp10)

(cffi:defcfun ("ScriptShapeOpenType" script-shape-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
  (c-chars :int32)   ; INT
  (c-max-glyphs :int32)   ; INT
  (pw-log-clust :pointer)   ; WORD* out
  (p-char-props :pointer)   ; SCRIPT_CHARPROP* out
  (pw-out-glyphs :pointer)   ; WORD* out
  (p-out-glyph-props :pointer)   ; SCRIPT_GLYPHPROP* out
  (pc-glyphs :pointer))   ; INT* out
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。
use Win32::API;
my $ScriptShapeOpenType = Win32::API::More->new('USP10',
    'int ScriptShapeOpenType(HANDLE hdc, LPVOID psc, LPVOID psa, DWORD tagScript, DWORD tagLangSys, LPVOID rcRangeChars, LPVOID rpRangeProperties, int cRanges, LPCWSTR pwcChars, int cChars, int cMaxGlyphs, LPVOID pwLogClust, LPVOID pCharProps, LPVOID pwOutGlyphs, LPVOID pOutGlyphProps, LPVOID pcGlyphs)');
# my $ret = $ScriptShapeOpenType->Call($hdc, $psc, $psa, $tagScript, $tagLangSys, $rcRangeChars, $rpRangeProperties, $cRanges, $pwcChars, $cChars, $cMaxGlyphs, $pwLogClust, $pCharProps, $pwOutGlyphs, $pOutGlyphProps, $pcGlyphs);
# 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
# cChars : INT -> int
# cMaxGlyphs : INT -> int
# pwLogClust : WORD* out -> LPVOID
# pCharProps : SCRIPT_CHARPROP* out -> LPVOID
# pwOutGlyphs : WORD* out -> LPVOID
# pOutGlyphProps : SCRIPT_GLYPHPROP* out -> LPVOID
# pcGlyphs : INT* out -> LPVOID
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。

関連項目

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