use crate::curves::Path;
use crate::math::Vector2;
pub trait Outline {
fn move_to(&mut self, x: f64, y: f64);
fn line_to(&mut self, x: f64, y: f64);
fn quad_to(&mut self, cx: f64, cy: f64, x: f64, y: f64);
fn cubic_to(&mut self, c1x: f64, c1y: f64, c2x: f64, c2y: f64, x: f64, y: f64);
fn close(&mut self);
}
#[derive(Default)]
pub struct PathSink {
pub path: Path,
start: Option<(f64, f64)>,
last: Option<(f64, f64)>,
}
impl PathSink {
fn to(&mut self, x: f64, y: f64) -> Vector2 {
self.last = Some((x, y));
Vector2::new(x as f32, y as f32)
}
}
impl Outline for PathSink {
fn move_to(&mut self, x: f64, y: f64) {
self.start = Some((x, y));
let p = self.to(x, y);
self.path.move_to(p);
}
fn line_to(&mut self, x: f64, y: f64) {
let p = self.to(x, y);
self.path.line_to(p);
}
fn quad_to(&mut self, cx: f64, cy: f64, x: f64, y: f64) {
let c = Vector2::new(cx as f32, cy as f32);
let p = self.to(x, y);
self.path.quadratic_curve_to(c, p);
}
fn cubic_to(&mut self, c1x: f64, c1y: f64, c2x: f64, c2y: f64, x: f64, y: f64) {
let c1 = Vector2::new(c1x as f32, c1y as f32);
let c2 = Vector2::new(c2x as f32, c2y as f32);
let p = self.to(x, y);
self.path.bezier_curve_to(c1, c2, p);
}
fn close(&mut self) {
if let (Some(s), Some(l)) = (self.start, self.last)
&& ((s.0 - l.0).abs() > 1e-6 || (s.1 - l.1).abs() > 1e-6)
{
let p = self.to(s.0, s.1);
self.path.line_to(p);
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct GlyphId(pub u16);
#[derive(Clone, Copy, Debug)]
pub(crate) struct Affine {
pub(crate) a: f64,
pub(crate) b: f64,
pub(crate) c: f64,
pub(crate) d: f64,
pub(crate) x: f64,
pub(crate) y: f64,
}
impl Affine {
pub(crate) const IDENTITY: Self = Self {
a: 1.0,
b: 0.0,
c: 0.0,
d: 1.0,
x: 0.0,
y: 0.0,
};
pub(crate) fn apply(self, px: f64, py: f64) -> (f64, f64) {
(
self.a * px + self.c * py + self.x,
self.b * px + self.d * py + self.y,
)
}
}
fn round_half_away(v: f64) -> f64 {
if v >= 0.0 {
((v + 0.5) as i64) as f64
} else {
-(((-v + 0.5) as i64) as f64)
}
}
fn i16_at(b: &[u8], p: usize) -> Option<i16> {
u16_at(b, p).map(|v| v as i16)
}
fn i32_at(b: &[u8], p: usize) -> Option<i32> {
u32_at(b, p).map(|v| v as i32)
}
fn u8_at(b: &[u8], p: usize) -> Option<u8> {
b.get(p).copied()
}
fn u16_at(b: &[u8], p: usize) -> Option<u16> {
Some(u16::from_be_bytes([*b.get(p)?, *b.get(p + 1)?]))
}
fn u32_at(b: &[u8], p: usize) -> Option<u32> {
Some(u32::from_be_bytes([
*b.get(p)?,
*b.get(p + 1)?,
*b.get(p + 2)?,
*b.get(p + 3)?,
]))
}
fn uint_at(b: &[u8], p: usize, size: usize) -> Option<u32> {
let mut v = 0u32;
for i in 0..size {
v = (v << 8) | u32::from(*b.get(p + i)?);
}
Some(v)
}
const MAX_DEPTH: u8 = 10;
const MAX_STACK: usize = 513;
const MAX_REGIONS: usize = 64;
#[derive(Clone, Copy, Debug, Default)]
struct Index<'a> {
data: &'a [u8],
count: usize,
off_size: usize,
offs: usize,
base: usize,
}
impl<'a> Index<'a> {
fn parse(data: &'a [u8], at: usize) -> Option<(Self, usize)> {
Self::parse_wide(data, at, false)
}
fn parse_wide(data: &'a [u8], at: usize, wide: bool) -> Option<(Self, usize)> {
let head = if wide { 4 } else { 2 };
let count = if wide {
u32_at(data, at)? as usize
} else {
usize::from(u16_at(data, at)?)
};
if count == 0 {
return Some((
Self {
data,
..Self::default()
},
at.checked_add(head)?,
));
}
let off_size = usize::from(u8_at(data, at.checked_add(head)?)?);
if off_size == 0 || off_size > 4 {
return None;
}
let offs = at.checked_add(head + 1)?;
let base = offs.checked_add(count.checked_add(1)?.checked_mul(off_size)?)? - 1;
let last = uint_at(
data,
offs.checked_add(count.checked_mul(off_size)?)?,
off_size,
)?;
let end = base.checked_add(last as usize)?;
if end > data.len() {
return None;
}
Some((
Self {
data,
count,
off_size,
offs,
base,
},
end,
))
}
fn get(&self, i: usize) -> Option<&'a [u8]> {
if i >= self.count {
return None;
}
let at = |k: usize| -> Option<usize> {
let o = uint_at(
self.data,
self.offs.checked_add(k.checked_mul(self.off_size)?)?,
self.off_size,
)?;
self.base.checked_add(o as usize)
};
let (a, b) = (at(i)?, at(i + 1)?);
self.data.get(a..b)
}
fn bias(&self) -> i32 {
if self.count < 1240 {
107
} else if self.count < 33900 {
1131
} else {
32768
}
}
}
fn dict_scan(d: &[u8], mut f: impl FnMut(u16, &[f64])) {
let mut ops = [0.0f64; MAX_STACK];
let mut n = 0usize;
let mut i = 0usize;
let push = |ops: &mut [f64; MAX_STACK], n: &mut usize, v: f64| {
if *n < MAX_STACK {
ops[*n] = v;
*n += 1;
}
};
while i < d.len() {
let b = d[i];
match b {
28 => {
let Some(v) = i16_at(d, i + 1) else { return };
push(&mut ops, &mut n, f64::from(v));
i += 3;
}
29 => {
let Some(v) = i32_at(d, i + 1) else { return };
push(&mut ops, &mut n, f64::from(v));
i += 5;
}
30 => {
let (v, next) = real_at(d, i + 1);
push(&mut ops, &mut n, v);
i = next;
}
32..=246 => {
push(&mut ops, &mut n, f64::from(i16::from(b) - 139));
i += 1;
}
247..=250 => {
let Some(&lo) = d.get(i + 1) else { return };
let v = (i32::from(b) - 247) * 256 + i32::from(lo) + 108;
push(&mut ops, &mut n, f64::from(v));
i += 2;
}
251..=254 => {
let Some(&lo) = d.get(i + 1) else { return };
let v = -((i32::from(b) - 251) * 256) - i32::from(lo) - 108;
push(&mut ops, &mut n, f64::from(v));
i += 2;
}
0..=31 => {
let (key, adv) = if b == 12 {
match d.get(i + 1) {
Some(&b2) => (0x0c00 | u16::from(b2), 2),
None => return,
}
} else {
(u16::from(b), 1)
};
f(key, &ops[..n]);
n = 0;
i += adv;
}
_ => return,
}
}
}
fn real_at(d: &[u8], mut i: usize) -> (f64, usize) {
let mut buf = [0u8; 40];
let mut n = 0usize;
let mut put = |b: u8, n: &mut usize| {
if *n < buf.len() {
buf[*n] = b;
*n += 1;
}
};
'outer: while i < d.len() {
let byte = d[i];
i += 1;
for nib in [byte >> 4, byte & 0x0f] {
match nib {
0..=9 => put(b'0' + nib, &mut n),
0x0a => put(b'.', &mut n),
0x0b => put(b'E', &mut n),
0x0c => {
put(b'E', &mut n);
put(b'-', &mut n);
}
0x0e => put(b'-', &mut n),
0x0f => break 'outer,
_ => {}
}
}
}
let v = core::str::from_utf8(&buf[..n])
.ok()
.and_then(|s| s.parse::<f64>().ok());
(v.unwrap_or(0.0), i)
}
fn fract(v: f64) -> f64 {
let g = 1_073_741_824.0;
round_half_away(v * g) / g
}
#[allow(dead_code)]
#[derive(Clone, Debug)]
pub(crate) struct Cff<'a> {
data: &'a [u8],
char_strings: Index<'a>,
gsubrs: Index<'a>,
subrs: Index<'a>,
fd_array: Option<Index<'a>>,
fd_select: Option<usize>,
xf: Affine,
wide: bool,
store: Option<super::ttf_var::ItemVariationStore<'a>>,
charset: usize,
pub(crate) std_stems: (f64, f64),
}
#[allow(dead_code)]
impl Cff<'_> {
pub(crate) fn glyph_for_sid(&self, sid: u16) -> Option<u16> {
match self.charset {
0 => (sid < 229 && usize::from(sid) < self.char_strings.count).then_some(sid),
1 | 2 => None,
at => {
let fmt = u8_at(self.data, at)?;
let n = u32::try_from(self.char_strings.count).ok()?;
let mut gid = 1u32;
match fmt {
0 => {
while gid < n {
let s = u16_at(self.data, at + 1 + (gid as usize - 1) * 2)?;
if s == sid {
return u16::try_from(gid).ok();
}
gid += 1;
}
None
}
1 | 2 => {
let step = if fmt == 1 { 3 } else { 4 };
let mut p = at + 1;
while gid < n {
let first = u16_at(self.data, p)?;
let left = if fmt == 1 {
u32::from(u8_at(self.data, p + 2)?)
} else {
u32::from(u16_at(self.data, p + 2)?)
};
if sid >= first && u32::from(sid - first) <= left {
return u16::try_from(gid + u32::from(sid - first)).ok();
}
gid += left + 1;
p += step;
}
None
}
_ => None,
}
}
}
}
}
impl<'a> Cff<'a> {
pub(crate) fn parse(data: &'a [u8], upem: u16, coords: &[f32]) -> Option<Self> {
let wide = u8_at(data, 0)? >= 2;
let hdr = usize::from(u8_at(data, 2)?);
if hdr < 4 {
return None;
}
let (top, gsubrs) = if wide {
let len = usize::from(u16_at(data, 3)?);
let top = data.get(hdr..hdr.checked_add(len)?)?;
let (gsubrs, _) = Index::parse_wide(data, hdr.checked_add(len)?, true)?;
(top, gsubrs)
} else {
let (_names, p) = Index::parse(data, hdr)?;
let (tops, p) = Index::parse(data, p)?;
let (_strings, p) = Index::parse(data, p)?;
let (gsubrs, _) = Index::parse(data, p)?;
(tops.get(0)?, gsubrs)
};
let (mut cs_off, mut priv_at, mut fda, mut fds) = (0usize, None, None, None);
let mut charset = 0usize;
let mut matrix = None;
let mut vstore = None;
dict_scan(top, |key, ops| match (key, ops) {
(17, [o, ..]) => cs_off = *o as usize,
(15, [o, ..]) => charset = *o as usize,
(24, [o, ..]) => vstore = Some(*o as usize + 2),
(18, [size, off, ..]) => priv_at = Some((*off as usize, *size as usize)),
(0x0c24, [o, ..]) => fda = Some(*o as usize),
(0x0c25, [o, ..]) => fds = Some(*o as usize),
(0x0c07, [a, b, c, d, x, y]) => {
let e = f64::from(upem);
matrix = Some(Affine {
a: fract(*a) * e,
b: fract(*b) * e,
c: fract(*c) * e,
d: fract(*d) * e,
x: fract(*x) * e,
y: fract(*y) * e,
});
}
_ => {}
});
if cs_off == 0 {
return None;
}
let (char_strings, _) = Index::parse_wide(data, cs_off, wide)?;
if char_strings.count == 0 {
return None;
}
Some(Self {
data,
char_strings,
gsubrs,
subrs: priv_at
.and_then(|(o, n)| private_subrs(data, o, n, wide))
.unwrap_or_default(),
fd_array: fda.and_then(|o| Index::parse_wide(data, o, wide).map(|(i, _)| i)),
fd_select: fds,
xf: matrix.unwrap_or(Affine::IDENTITY),
wide,
store: vstore.and_then(|at| super::ttf_var::ItemVariationStore::new(data, at, coords)),
charset,
std_stems: priv_at
.and_then(|(o, n)| private_stems(data, o, n))
.or_else(|| {
let fda = fda.and_then(|o| Index::parse_wide(data, o, wide).map(|(i, _)| i))?;
let fd = fda.get(0)?;
let mut at = None;
dict_scan(fd, |key, ops| {
if let (18, [size, off, ..]) = (key, ops) {
at = Some((*off as usize, *size as usize));
}
});
let (o, n) = at?;
private_stems(data, o, n)
})
.unwrap_or((0.0, 0.0)),
})
}
fn local(&self, glyph: GlyphId) -> Index<'a> {
let Some(fda) = self.fd_array else {
return self.subrs;
};
let fd = match self.fd_select {
Some(at) => fd_select(self.data, at, glyph).unwrap_or(0),
None => 0,
};
let Some(dict) = fda.get(usize::from(fd)) else {
return self.subrs;
};
let mut priv_at = None;
dict_scan(dict, |key, ops| {
if let (18, [size, off, ..]) = (key, ops) {
priv_at = Some((*off as usize, *size as usize));
}
});
priv_at
.and_then(|(o, n)| private_subrs(self.data, o, n, self.wide))
.unwrap_or_default()
}
fn region_scalars(&self, index: usize) -> Option<(usize, [f64; MAX_REGIONS])> {
let scalars = self
.store
.as_ref()?
.region_scalars(u16::try_from(index).ok()?)?;
if scalars.len() > MAX_REGIONS {
return None;
}
let mut out = [0.0f64; MAX_REGIONS];
for (slot, s) in out.iter_mut().zip(&scalars) {
*slot = f64::from(*s);
}
Some((scalars.len(), out))
}
pub(crate) fn draw(&self, glyph: GlyphId, sink: &mut dyn Outline) -> Option<()> {
let code = self.char_strings.get(usize::from(glyph.0))?;
let mut run = Run {
cff: self,
subrs: self.local(glyph),
sink,
xf: self.xf,
st: [0.0; MAX_STACK],
n: 0,
x: 0.0,
y: 0.0,
open: false,
stems: 0,
width: self.wide,
regions: None,
vsindex: 0,
};
run.exec(code, 0)?;
if run.open {
run.sink.close();
}
Some(())
}
}
fn private_subrs<'a>(data: &'a [u8], off: usize, size: usize, wide: bool) -> Option<Index<'a>> {
let dict = data.get(off..off.checked_add(size)?)?;
let mut subrs = None;
dict_scan(dict, |key, ops| {
if let (19, [o, ..]) = (key, ops) {
subrs = Some(*o as usize);
}
});
let at = off.checked_add(subrs?)?;
Index::parse_wide(data, at, wide).map(|(i, _)| i)
}
fn private_stems(data: &[u8], off: usize, size: usize) -> Option<(f64, f64)> {
let dict = data.get(off..off.checked_add(size)?)?;
let (mut h, mut v) = (0.0, 0.0);
dict_scan(dict, |key, ops| match (key, ops) {
(10, [x, ..]) => h = *x,
(11, [x, ..]) => v = *x,
_ => {}
});
Some((h, v))
}
fn fd_select(data: &[u8], at: usize, glyph: GlyphId) -> Option<u8> {
let g = usize::from(glyph.0);
match u8_at(data, at)? {
0 => u8_at(data, at.checked_add(1)?.checked_add(g)?),
3 => {
let n = usize::from(u16_at(data, at + 1)?);
let recs = at.checked_add(3)?;
let sentinel = usize::from(u16_at(data, recs.checked_add(n.checked_mul(3)?)?)?);
if g >= sentinel {
return None;
}
let (mut lo, mut hi) = (0usize, n);
while lo + 1 < hi {
let mid = (lo + hi) / 2;
if usize::from(u16_at(data, recs + mid * 3)?) <= g {
lo = mid;
} else {
hi = mid;
}
}
if usize::from(u16_at(data, recs + lo * 3)?) > g {
return None;
}
u8_at(data, recs + lo * 3 + 2)
}
_ => None,
}
}
struct Run<'a, 'b> {
cff: &'b Cff<'a>,
subrs: Index<'a>,
sink: &'b mut dyn Outline,
xf: Affine,
st: [f64; MAX_STACK],
n: usize,
x: f64,
y: f64,
open: bool,
stems: usize,
width: bool,
regions: Option<(usize, [f64; MAX_REGIONS])>,
vsindex: usize,
}
impl Run<'_, '_> {
fn push(&mut self, v: f64) -> Option<()> {
if self.n >= MAX_STACK {
return None;
}
self.st[self.n] = v;
self.n += 1;
Some(())
}
fn args(&mut self, nominal: Option<usize>) -> usize {
if self.width {
return 0;
}
self.width = true;
let extra = match nominal {
Some(k) => self.n > k,
None => self.n % 2 == 1,
};
usize::from(extra)
}
fn move_to(&mut self, x: f64, y: f64) {
if self.open {
self.sink.close();
}
self.x = x;
self.y = y;
let (px, py) = self.xf.apply(x, y);
self.sink.move_to(px, py);
self.open = true;
}
fn line_to(&mut self, x: f64, y: f64) {
self.x = x;
self.y = y;
let (px, py) = self.xf.apply(x, y);
self.sink.line_to(px, py);
}
fn curve_to(&mut self, c1: (f64, f64), c2: (f64, f64), to: (f64, f64)) {
self.x = to.0;
self.y = to.1;
let a = self.xf.apply(c1.0, c1.1);
let b = self.xf.apply(c2.0, c2.1);
let e = self.xf.apply(to.0, to.1);
self.sink.cubic_to(a.0, a.1, b.0, b.1, e.0, e.1);
}
fn exec(&mut self, code: &[u8], depth: u8) -> Option<bool> {
if depth > MAX_DEPTH {
return None;
}
let mut i = 0usize;
while i < code.len() {
let b = code[i];
i += 1;
match b {
28 => {
let v = i16_at(code, i)?;
i += 2;
self.push(f64::from(v))?;
}
32..=246 => self.push(f64::from(i16::from(b) - 139))?,
247..=250 => {
let lo = *code.get(i)?;
i += 1;
self.push(f64::from((i32::from(b) - 247) * 256 + i32::from(lo) + 108))?;
}
251..=254 => {
let lo = *code.get(i)?;
i += 1;
self.push(f64::from(
-((i32::from(b) - 251) * 256) - i32::from(lo) - 108,
))?;
}
255 => {
let v = i32_at(code, i)?;
i += 4;
self.push(f64::from(v) / 65536.0)?;
}
1 | 3 | 18 | 23 => {
let s = self.args(None);
self.stems += (self.n - s) / 2;
self.n = 0;
}
19 | 20 => {
let s = self.args(None);
self.stems += (self.n - s) / 2;
self.n = 0;
let bytes = self.stems.div_ceil(8);
i = i.checked_add(bytes)?;
if i > code.len() {
return None;
}
}
21 => {
let s = self.args(Some(2));
let (dx, dy) = (*self.st.get(s)?, *self.st.get(s + 1)?);
self.move_to(self.x + dx, self.y + dy);
self.n = 0;
}
22 | 4 => {
let s = self.args(Some(1));
let d = *self.st.get(s)?;
if b == 22 {
self.move_to(self.x + d, self.y);
} else {
self.move_to(self.x, self.y + d);
}
self.n = 0;
}
5 => {
let mut k = 0;
while k + 2 <= self.n {
self.line_to(self.x + self.st[k], self.y + self.st[k + 1]);
k += 2;
}
self.n = 0;
}
6 | 7 => {
let mut horizontal = b == 6;
for k in 0..self.n {
let d = self.st[k];
if horizontal {
self.line_to(self.x + d, self.y);
} else {
self.line_to(self.x, self.y + d);
}
horizontal = !horizontal;
}
self.n = 0;
}
8 => {
let mut k = 0;
while k + 6 <= self.n {
self.rel_curve(k);
k += 6;
}
self.n = 0;
}
24 => {
let mut k = 0;
while self.n - k >= 8 {
self.rel_curve(k);
k += 6;
}
if k + 2 <= self.n {
self.line_to(self.x + self.st[k], self.y + self.st[k + 1]);
}
self.n = 0;
}
25 => {
let mut k = 0;
while self.n - k >= 8 {
self.line_to(self.x + self.st[k], self.y + self.st[k + 1]);
k += 2;
}
if k + 6 <= self.n {
self.rel_curve(k);
}
self.n = 0;
}
26 | 27 => {
let mut k = 0;
let mut off = 0.0;
if (self.n - k) % 4 == 1 {
off = self.st[0];
k = 1;
}
while k + 4 <= self.n {
let (a, b2, c, d) =
(self.st[k], self.st[k + 1], self.st[k + 2], self.st[k + 3]);
let (c1, c2, to) = if b == 26 {
let c1 = (self.x + off, self.y + a);
let c2 = (c1.0 + b2, c1.1 + c);
(c1, c2, (c2.0, c2.1 + d))
} else {
let c1 = (self.x + a, self.y + off);
let c2 = (c1.0 + b2, c1.1 + c);
(c1, c2, (c2.0 + d, c2.1))
};
off = 0.0;
self.curve_to(c1, c2, to);
k += 4;
}
self.n = 0;
}
30 | 31 => {
let mut horizontal = b == 31;
let mut k = 0;
while self.n - k >= 4 {
let last = self.n - k == 5;
let (a, b2, c, d) =
(self.st[k], self.st[k + 1], self.st[k + 2], self.st[k + 3]);
let e = if last { self.st[k + 4] } else { 0.0 };
let (c1, c2, to) = if horizontal {
let c1 = (self.x + a, self.y);
let c2 = (c1.0 + b2, c1.1 + c);
(c1, c2, (c2.0 + e, c2.1 + d))
} else {
let c1 = (self.x, self.y + a);
let c2 = (c1.0 + b2, c1.1 + c);
(c1, c2, (c2.0 + d, c2.1 + e))
};
self.curve_to(c1, c2, to);
horizontal = !horizontal;
k += 4;
}
self.n = 0;
}
10 | 29 => {
if self.n == 0 {
return None;
}
self.n -= 1;
let v = self.st[self.n];
let arr = if b == 10 { self.subrs } else { self.cff.gsubrs };
#[allow(clippy::cast_possible_truncation)]
let idx = v as i32 + arr.bias();
if idx < 0 {
return None;
}
let sub = arr.get(idx as usize)?;
if self.exec(sub, depth + 1)? {
return Some(true);
}
}
11 => return Some(false),
15 if self.cff.wide => {
if self.n == 0 {
return None;
}
self.n -= 1;
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
let v = self.st[self.n] as usize;
self.vsindex = v;
self.regions = None;
}
16 if self.cff.wide => {
if self.n == 0 {
return None;
}
self.n -= 1;
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
let k = self.st[self.n] as usize;
let (regions, scalars) = match self.regions {
Some(r) => r,
None => {
let r = self.cff.region_scalars(self.vsindex)?;
self.regions = Some(r);
r
}
};
let deltas = k.checked_mul(regions)?;
if deltas > self.n || k > self.n - deltas {
return None;
}
let base = self.n - deltas - k;
for i in 0..k {
let mut v = self.st[base + i];
for (j, s) in scalars.iter().enumerate().take(regions) {
v = f64::mul_add(*s, self.st[base + k + i * regions + j], v);
}
self.st[base + i] = v;
}
self.n = base + k;
}
14 if !self.cff.wide => {
let s = self.args(Some(0));
if self.n - s >= 4 {
return None;
}
return Some(true);
}
12 => {
let b2 = *code.get(i)?;
i += 1;
match b2 {
35 if self.n >= 13 => {
self.rel_curve(0);
self.rel_curve(6);
self.n = 0;
}
34 if self.n >= 7 => {
let y0 = self.y;
let a = self.st;
let c1 = (self.x + a[0], y0);
let c2 = (c1.0 + a[1], c1.1 + a[2]);
self.curve_to(c1, c2, (c2.0 + a[3], c2.1));
let c3 = (self.x + a[4], self.y);
let c4 = (c3.0 + a[5], y0);
self.curve_to(c3, c4, (c4.0 + a[6], y0));
self.n = 0;
}
36 if self.n >= 9 => {
let y0 = self.y;
let a = self.st;
let c1 = (self.x + a[0], self.y + a[1]);
let c2 = (c1.0 + a[2], c1.1 + a[3]);
self.curve_to(c1, c2, (c2.0 + a[4], c2.1));
let c3 = (self.x + a[5], self.y);
let c4 = (c3.0 + a[6], c3.1 + a[7]);
self.curve_to(c3, c4, (c4.0 + a[8], y0));
self.n = 0;
}
37 if self.n >= 11 => {
let (x0, y0) = (self.x, self.y);
let a = self.st;
let dx = a[0] + a[2] + a[4] + a[6] + a[8];
let dy = a[1] + a[3] + a[5] + a[7] + a[9];
self.rel_curve(0);
let c3 = (self.x + a[6], self.y + a[7]);
let c4 = (c3.0 + a[8], c3.1 + a[9]);
let to = if dx.abs() > dy.abs() {
(c4.0 + a[10], y0)
} else {
(x0, c4.1 + a[10])
};
self.curve_to(c3, c4, to);
self.n = 0;
}
_ => return None,
}
}
_ => return None,
}
}
Some(false)
}
fn rel_curve(&mut self, k: usize) {
let a = self.st;
let c1 = (self.x + a[k], self.y + a[k + 1]);
let c2 = (c1.0 + a[k + 2], c1.1 + a[k + 3]);
self.curve_to(c1, c2, (c2.0 + a[k + 4], c2.1 + a[k + 5]));
}
}