use super::ttf_var::ItemVariationStore;
fn u16_at(b: &[u8], p: usize) -> Option<u16> {
Some(u16::from_be_bytes([*b.get(p)?, *b.get(p + 1)?]))
}
fn i16_at(b: &[u8], p: usize) -> Option<i16> {
u16_at(b, p).map(|v| v as i16)
}
const CLASS_MARK: u16 = 3;
#[derive(Clone, Copy, Default, PartialEq, Debug)]
pub struct Attachment {
pub to: Option<u16>,
pub dx: f32,
pub dy: f32,
}
pub(crate) struct Marks<'a> {
gpos: &'a [u8],
gdef: &'a [u8],
lookups: Vec<u16>,
mkmk_at: usize,
classes: Option<usize>,
store: Option<&'a ItemVariationStore<'a>>,
}
impl<'a> Marks<'a> {
pub(crate) fn parse(
gpos: &'a [u8],
gdef: &'a [u8],
store: Option<&'a ItemVariationStore<'a>>,
) -> Option<Self> {
if u16_at(gpos, 0)? != 1 {
return None;
}
let features = usize::from(u16_at(gpos, 6)?);
let count = usize::from(u16_at(gpos, features)?);
let mut lookups = Vec::new();
let mut mkmk_at = 0usize;
for tag in [b"mark", b"mkmk"] {
if tag == b"mkmk" {
mkmk_at = lookups.len();
}
for i in 0..count {
let rec = features + 2 + 6 * i;
if gpos.get(rec..rec + 4) != Some(&tag[..]) {
continue;
}
let f = features + usize::from(u16_at(gpos, rec + 4)?);
for k in 0..usize::from(u16_at(gpos, f + 2)?) {
if let Some(l) = u16_at(gpos, f + 4 + 2 * k) {
lookups.push(l);
}
}
}
}
if lookups.is_empty() {
return None;
}
let classes = match u16_at(gdef, 4) {
Some(0) | None => None,
Some(o) => Some(usize::from(o)),
};
Some(Self {
gpos,
gdef,
lookups,
mkmk_at,
classes,
store,
})
}
pub(crate) fn attach(&self, glyphs: &[u16]) -> Vec<Attachment> {
let is_mark = |g: u16| {
self.classes
.is_some_and(|at| super::gpos::class_of(self.gdef, at, g) == CLASS_MARK)
};
let mut out = vec![Attachment::default(); glyphs.len()];
for (i, g) in glyphs.iter().enumerate() {
if !is_mark(*g) {
continue;
}
if let Some(b) = (0..i).rev().find(|j| !is_mark(glyphs[*j]))
&& let Some((dx, dy)) = self.anchor_pair(*g, glyphs[b], 0, self.mkmk_at)
{
out[i] = Attachment {
to: u16::try_from(b).ok(),
dx,
dy,
};
}
if i > 0
&& is_mark(glyphs[i - 1])
&& let Some((dx, dy)) =
self.anchor_pair(*g, glyphs[i - 1], self.mkmk_at, self.lookups.len())
{
out[i] = Attachment {
to: u16::try_from(i - 1).ok(),
dx,
dy,
};
}
}
out
}
fn anchor_pair(&self, mark: u16, to: u16, from: usize, until: usize) -> Option<(f32, f32)> {
for index in self.lookups.get(from..until.min(self.lookups.len()))? {
for (kind, sub) in super::gpos::lookup_subtables(self.gpos, 0, *index, 9)? {
if let Some(d) = self.mark_pos(kind, sub, mark, to) {
return Some(d);
}
}
}
None
}
fn mark_pos(&self, kind: u16, sub: usize, mark: u16, to: u16) -> Option<(f32, f32)> {
if !(4..=6).contains(&kind) || u16_at(self.gpos, sub)? != 1 {
return None;
}
let b = self.gpos;
let mark_cov = super::gpos::parse_coverage(b, sub + usize::from(u16_at(b, sub + 2)?))?;
let to_cov = super::gpos::parse_coverage(b, sub + usize::from(u16_at(b, sub + 4)?))?;
let mark_index = usize::from(mark_cov.get(&mark).copied()?);
let to_index = usize::from(to_cov.get(&to).copied()?);
let class_count = usize::from(u16_at(b, sub + 6)?);
let mark_array = sub + usize::from(u16_at(b, sub + 8)?);
let second = sub + usize::from(u16_at(b, sub + 10)?);
if mark_index >= usize::from(u16_at(b, mark_array)?) {
return None;
}
let rec = mark_array + 2 + mark_index * 4;
let class = usize::from(u16_at(b, rec)?);
if class >= class_count {
return None;
}
let mark_anchor = usize::from(u16_at(b, rec + 2)?);
if mark_anchor == 0 {
return None;
}
let (mx, my) = self.anchor(mark_array + mark_anchor)?;
if to_index >= usize::from(u16_at(b, second)?) {
return None;
}
let row = if kind == 5 {
let lig = second + usize::from(u16_at(b, second + 2 + to_index * 2)?);
let components = usize::from(u16_at(b, lig)?);
if components == 0 {
return None;
}
lig + 2 + (components - 1) * class_count * 2
} else {
second + 2 + to_index * class_count * 2
};
let to_anchor = usize::from(u16_at(b, row + class * 2)?);
if to_anchor == 0 {
return None;
}
let (bx, by) = self.anchor(second + to_anchor)?;
Some((bx - mx, by - my))
}
fn anchor(&self, at: usize) -> Option<(f32, f32)> {
let b = self.gpos;
let format = u16_at(b, at)?;
let mut x = f32::from(i16_at(b, at + 2)?);
let mut y = f32::from(i16_at(b, at + 4)?);
if format == 3 {
for (slot, v) in [(6usize, &mut x), (8, &mut y)] {
let device = usize::from(u16_at(b, at + slot)?);
if device == 0 {
continue;
}
let d = at + device;
if u16_at(b, d + 4)? != 0x8000 {
continue;
}
let (outer, inner) = (u16_at(b, d)?, u16_at(b, d + 2)?);
if let Some(s) = self.store {
*v += s.delta(outer, inner);
}
}
}
Some((x, y))
}
}