README

moonbit-community/harfbuzz/ot/var does not have a README file

#
VarError

pub suberror VarError {
UnexpectedEof
InvalidFormat
} derive(Eq, Show, ToJson)

#
AvarMapping

pub struct AvarMapping {
from_raw : Int
to_raw : Int
} derive(Eq, Show, ToJson)

#
AvarSegmentMap

pub struct AvarSegmentMap {
mappings : Array[AvarMapping]
} derive(Eq, Show, ToJson)

#
AvarSegmentMap::map_value

fn AvarSegmentMap::map_value(self : AvarSegmentMap, value : Double) -> Double

#
AvarTable

pub struct AvarTable {
axes : Array[AvarSegmentMap]
} derive(Eq, Show, ToJson)

#
AvarTable::axis_count

fn AvarTable::axis_count(self : AvarTable) -> Int

#
AvarTable::map_coords_16_16

fn AvarTable::map_coords_16_16(self : AvarTable, coords : Array[Int]) -> Array[Int]

#
AvarTable::parse

fn AvarTable::parse(data : BytesView) -> Result[AvarTable, VarError]

#
AxisCoord

pub struct AxisCoord {
tag :
Tag

value : Double
} derive(Eq, Show, ToJson)

#
AxisCoord::new

#
AxisRecord

pub struct AxisRecord {
tag :
Tag

min_value : Double
default_value : Double
max_value : Double
flags : Int
name_id : Int
} derive(Eq, Show, ToJson)

#
AxisRecord::normalize_value

fn AxisRecord::normalize_value(self : AxisRecord, value : Double) -> Double

#
CffIndex

type CffIndex derive(Show, ToJson)

#
CvarTable

pub struct CvarTable {
version : Int
tuple_data : TupleVariationData
} derive(Show, ToJson)

#
CvarTable::apply_to_cvt

fn CvarTable::apply_to_cvt(self : CvarTable, cvt : Array[Int], coords : Array[Int]) -> Result[Array[Int], VarError]

#
CvarTable::cvt_deltas

fn CvarTable::cvt_deltas(self : CvarTable, coords : Array[Int], point_count : Int) -> Result[Array[Double], VarError]

#
CvarTable::parse

fn CvarTable::parse(data : BytesView, axis_count : Int) -> Result[CvarTable, VarError]

#
DeltaSetIndexMap

pub struct DeltaSetIndexMap {
map_count : Int
width : Int
inner_bit_count : Int
map_data : Bytes
} derive(Eq, Show, ToJson)

#
DeltaSetIndexMap::map

fn DeltaSetIndexMap::map(self : DeltaSetIndexMap, value : UInt) -> UInt

#
DeltaSetIndexMap::parse

fn DeltaSetIndexMap::parse(data : BytesView, offset : Int) -> Result[DeltaSetIndexMap, VarError]

#
FvarTable

pub struct FvarTable {
axes : Array[AxisRecord]
instances : Array[InstanceRecord]
} derive(Eq, Show, ToJson)

#
FvarTable::axes

#
FvarTable::axis_index

fn FvarTable::axis_index(self : FvarTable, tag :
Tag
) -> Int?

#
FvarTable::instances

fn FvarTable::instances(self : FvarTable) -> ArrayView[InstanceRecord]

#
FvarTable::normalize_axis_value

fn FvarTable::normalize_axis_value(self : FvarTable, axis_index : Int, value : Double) -> Double

#
FvarTable::normalize_design_coords

fn FvarTable::normalize_design_coords(self : FvarTable, coords : Array[Double]) -> Array[Int]

#
FvarTable::parse

fn FvarTable::parse(data : BytesView) -> Result[FvarTable, VarError]

#
GvarTable

pub struct GvarTable {
axis_count : Int
shared_tuple_count : Int
shared_tuples_offset : Int
glyph_count : Int
flags : Int
data_offset : Int
offsets : Array[Int]
data : Bytes
} derive(Show, ToJson)

#
GvarTable::glyph_deltas

fn GvarTable::glyph_deltas(self : GvarTable, glyph : Int, coords : Array[Int], point_count : Int) -> Result[(Array[Double], Array[Double]?), VarError]

#
GvarTable::glyph_tuple_variations

fn GvarTable::glyph_tuple_variations(self : GvarTable, glyph : Int) -> Result[TupleVariationData?, VarError]

#
GvarTable::glyph_variation_data

fn GvarTable::glyph_variation_data(self : GvarTable, glyph : Int) -> Bytes?

#
GvarTable::parse

fn GvarTable::parse(data : BytesView) -> Result[GvarTable, VarError]

#
GvarTable::shared_tuples

fn GvarTable::shared_tuples(self : GvarTable) -> Result[Array[Int], VarError]

#
HvarTable

pub struct HvarTable {
var_store : ItemVariationStore
adv_map : DeltaSetIndexMap?
lsb_map : DeltaSetIndexMap?
rsb_map : DeltaSetIndexMap?
} derive(Show, ToJson)

#
HvarTable::advance_delta

fn HvarTable::advance_delta(self : HvarTable, glyph : UInt, coords : Array[Int]) -> Double

#
HvarTable::lsb_delta

fn HvarTable::lsb_delta(self : HvarTable, glyph : UInt, coords : Array[Int]) -> Double

#
HvarTable::parse

fn HvarTable::parse(data : BytesView) -> Result[HvarTable, VarError]

#
HvarTable::rsb_delta

fn HvarTable::rsb_delta(self : HvarTable, glyph : UInt, coords : Array[Int]) -> Double

#
InstanceRecord

pub struct InstanceRecord {
subfamily_name_id : Int
flags : Int
coordinates : Array[Double]
postscript_name_id : Int?
} derive(Eq, Show, ToJson)

#
ItemVariationStore

pub struct ItemVariationStore {
region_list : VarRegionList
data_sets : Array[VarData]
} derive(Eq, Show, ToJson)

#
ItemVariationStore::get_delta

fn ItemVariationStore::get_delta(self : ItemVariationStore, var_idx : UInt, coords : Array[Int]) -> Double

#
ItemVariationStore::parse

fn ItemVariationStore::parse(data : BytesView) -> Result[ItemVariationStore, VarError]

#
ItemVariationStore::region_count

fn ItemVariationStore::region_count(self : ItemVariationStore, outer : Int) -> Int?

#
ItemVariationStore::region_scalars

fn ItemVariationStore::region_scalars(self : ItemVariationStore, outer : Int, coords : Array[Int]) -> Array[Double]?

#
MultiItemVariationStore

pub struct MultiItemVariationStore {
region_list : SparseVarRegionList
data_sets : Array[MultiVarData]
} derive(Show, ToJson)

#
MultiItemVariationStore::get_delta

fn MultiItemVariationStore::get_delta(self : MultiItemVariationStore, var_idx : UInt, coords : Array[Int], out : Array[Double]) -> Unit

#
MultiItemVariationStore::parse

fn MultiItemVariationStore::parse(data : BytesView) -> Result[MultiItemVariationStore, VarError]

#
MultiVarData

pub struct MultiVarData {
region_indices : Array[Int]
delta_sets : CffIndex
} derive(Show, ToJson)

#
MvarRecord

pub struct MvarRecord {
tag :
Tag

var_idx : UInt
} derive(Eq, Show, ToJson)

#
MvarTable

pub struct MvarTable {
records : Array[MvarRecord]
var_store : ItemVariationStore
} derive(Show, ToJson)

#
MvarTable::get_var

fn MvarTable::get_var(self : MvarTable, tag :
Tag
, coords : Array[Int]) -> Double

#
MvarTable::parse

fn MvarTable::parse(data : BytesView) -> Result[MvarTable, VarError]

#
SparseVarRegionAxis

pub struct SparseVarRegionAxis {
axis_index : Int
axis : VarRegionAxis
} derive(Eq, Show, ToJson)

#
SparseVarRegionList

pub struct SparseVarRegionList {
regions : Array[SparseVariationRegion]
} derive(Eq, Show, ToJson)

#
SparseVariationRegion

pub struct SparseVariationRegion {
axes : Array[SparseVarRegionAxis]
} derive(Eq, Show, ToJson)

#
TupleHeader

type TupleHeader derive(Show, ToJson)

#
TupleVariation

pub struct TupleVariation {
peak : Array[Int]
start : Array[Int]?
end : Array[Int]?
indices : Array[Int]?
deltas_x : Array[Int]
deltas_y : Array[Int]?
} derive(Show, ToJson)

#
TupleVariation::scalar

fn TupleVariation::scalar(self : TupleVariation, coords : Array[Int]) -> Double

#
TupleVariationData

pub struct TupleVariationData {
axis_count : Int
tuple_headers : Array[TupleHeader]
shared_points : Array[Int]?
shared_points_size : Int
data_offset : Int
data : Bytes
} derive(Show, ToJson)

#
TupleVariationData::apply

fn TupleVariationData::apply(self : TupleVariationData, coords : Array[Int], point_count : Int, is_gvar : Bool) -> Result[(Array[Double], Array[Double]?), VarError]

#
TupleVariationData::decode

fn TupleVariationData::decode(self : TupleVariationData, point_count : Int, is_gvar : Bool) -> Result[Array[TupleVariation], VarError]

#
TupleVariationData::parse

fn TupleVariationData::parse(data : BytesView, axis_count : Int, shared_tuples : Array[Int]) -> Result[TupleVariationData, VarError]

#
VarData

pub(all) struct VarData {
item_count : Int
word_count : Int
long_words : Bool
region_indices : Array[Int]
deltas : Bytes
} derive(Eq, Show, ToJson)

#
VarRegionAxis

pub(all) struct VarRegionAxis {
start_coord : Int
peak_coord : Int
end_coord : Int
} derive(Eq, Show, ToJson)

#
VarRegionList

pub(all) struct VarRegionList {
axis_count : Int
region_count : Int
axes : Array[VarRegionAxis]
} derive(Eq, Show, ToJson)

#
VarcComponent

pub struct VarcComponent {
glyph : Int
visible : Bool
axis_indices : Array[Int]
axis_values : Array[Double]
coords : Array[Int]
transform : VarcTransform
} derive(Show, ToJson)

#
VarcCondition

pub enum VarcCondition {
AxisRange(Int, Int, Int)
Value(Int, Int)
And(Array[VarcCondition])
Or(Array[VarcCondition])
Not(VarcCondition)
} derive(Show, ToJson)

#
VarcCondition::evaluate

fn VarcCondition::evaluate(self : VarcCondition, coords : Array[Int], var_delta : (Int) -> Double?) -> Bool

#
VarcTable

pub struct VarcTable {
version : Int
coverage_offset : Int
var_store_offset : Int
condition_list_offset : Int
axis_indices_offset : Int
glyph_records_offset : Int
data : Bytes
} derive(Show, ToJson)

#
VarcTable::axis_indices

fn VarcTable::axis_indices(self : VarcTable, index : Int) -> Result[Array[Int], VarError]

#
VarcTable::conditions

fn VarcTable::conditions(self : VarcTable) -> Result[Array[VarcCondition], VarError]

#
VarcTable::glyph_components

fn VarcTable::glyph_components(self : VarcTable, glyph : Int, coords : Array[Int], base_coords : Array[Int]) -> Result[Array[VarcComponent], VarError]

#
VarcTable::glyph_record

fn VarcTable::glyph_record(self : VarcTable, glyph : Int) -> Result[Bytes?, VarError]

#
VarcTable::parse

fn VarcTable::parse(data : BytesView) -> Result[VarcTable, VarError]

#
VarcTable::var_store

fn VarcTable::var_store(self : VarcTable) -> Result[MultiItemVariationStore?, VarError]

#
VarcTransform

pub struct VarcTransform {
translate_x : Double
translate_y : Double
rotation : Double
scale_x : Double
scale_y : Double
skew_x : Double
skew_y : Double
tcenter_x : Double
tcenter_y : Double
} derive(Show, ToJson)

#
VarcTransform::apply_to_bounds

fn VarcTransform::apply_to_bounds(self : VarcTransform, x_min : Double, y_min : Double, x_max : Double, y_max : Double) -> (Double, Double, Double, Double)

#
VarcTransform::apply_to_point

fn VarcTransform::apply_to_point(self : VarcTransform, x : Double, y : Double) -> (Double, Double)

#
fixed16_to_f2dot14

fn fixed16_to_f2dot14(raw : Int) -> Int