EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Sonar: reduce cognitive complexity in footage reload, edit delete and text layout
Dylan M. Taylorc61842925258
diff --git a/crates/engine/src/commands/edit.rs b/crates/engine/src/commands/edit.rsindex 4f79e5271..d0dbabb5b 100644--- a/crates/engine/src/commands/edit.rs+++ b/crates/engine/src/commands/edit.rs@@ -2,7 +2,7 @@use effectcraft_color::Label;use effectcraft_keyframe::Value as KV;-use effectcraft_project::{Comp, Expression, ItemKind, Layer, LayerId, LayerSource, TrackMatte};+use effectcraft_project::{Comp, Expression, ItemId, ItemKind, Layer, LayerId, LayerSource, TrackMatte};use effectcraft_time::Tick;use serde_json::{Value, json};@@ -160,45 +160,62 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {/// at a removed layer and rewrites layer-reference values and keys to `None` in the same undo/// step; the text-edit session is then sanitized so a removed layer's editor is not reused.fn delete(s: &mut Session, p: &Value) -> Result<Value> {- if s.state.text_edit.is_some() && p.get("layers").is_none() {- return s.execute("text.delete", json!({}));+ if let Some(done) = delete_selection(s, p)? {+ return Ok(done);+ }+ let (cid, ids) = layers_p(s, p)?;+ let ids = super::unlocked(s, cid, ids, "edit.clear")?;+ clear_layers(s, cid, &ids)?;+ // A removed layer may have been the edited one: end that session before another command+ // can reuse it. Undo restores a layer as a new editor, never by reviving the old IME session.+ s.sanitize_state();+ Ok(json!(ids.len()))+}++/// Deletes the selected things that are not layers. `None` when the layers are deleted+/// instead (nothing else is selected, or the command names its layers).+fn delete_selection(s: &mut Session, p: &Value) -> Result<Option<Value>> {+ let no_layers = p.get("layers").is_none();+ if s.state.text_edit.is_some() && no_layers {+ return Ok(Some(s.execute("text.delete", json!({}))?));}// Time Remap selected (its name, which selects all its keys) → time remapping off, not the// layer (After Effects).- if p.get("layers").is_none() {+ if no_layers {let remapped = super::layer_time::selected_time_remap(s);if !remapped.is_empty() {- return super::layer_time::disable_time_remap(s, &remapped);+ return Ok(Some(super::layer_time::disable_time_remap(s, &remapped)?));}}// Keyframes selected → delete keys; mask vertices → delete them; else layers.- if !s.state.selected_keys.is_empty() && p.get("layers").is_none() {- return s.execute("keys.delete", json!({}));+ if !s.state.selected_keys.is_empty() && no_layers {+ return Ok(Some(s.execute("keys.delete", json!({}))?));}// (Points selected with their mask, which selecting a mask does: the mask goes, below.)let comp = s.active_comp();let loose = s.state.selected_vertices.iter().any(|v| {!s.state.selected_props.contains(&(v.layer, v.mask)) && comp.and_then(|c| c.layer(v.layer)).is_some_and(|l| l.props.find_group(v.mask).is_some())});- if loose && p.get("layers").is_none() {- return s.execute("mask.deleteVertices", json!({}));+ if loose && no_layers {+ return Ok(Some(s.execute("mask.deleteVertices", json!({}))?));}// Puppet pins selected → delete the pins (not their layer).- if p.get("layers").is_none() && !super::puppet::selected_pins(s).is_empty() {- return s.execute("puppet.removePin", json!({}));+ if no_layers && !super::puppet::selected_pins(s).is_empty() {+ return Ok(Some(s.execute("puppet.removePin", json!({}))?));}// Effects selected → remove them.- if p.get("layers").is_none() && !super::effect::selected_effects(s).is_empty() {- return s.execute("effect.remove", json!({}));+ if no_layers && !super::effect::selected_effects(s).is_empty() {+ return Ok(Some(s.execute("effect.remove", json!({}))?));}// Masks, shape items, text animators or trackers selected → remove them.- if p.get("layers").is_none()- && let Some(n) = super::prop_groups::remove_selected(s)?- {- return Ok(n);+ if no_layers && let Some(n) = super::prop_groups::remove_selected(s)? {+ return Ok(Some(n));}- let (cid, ids) = layers_p(s, p)?;- let ids = super::unlocked(s, cid, ids, "edit.clear")?;+ Ok(None)+}++/// Removes layers `ids` from comp `cid` in one undoable step, and clears what referred to them.+fn clear_layers(s: &mut Session, cid: ItemId, ids: &[LayerId]) -> Result<()> {// Children of deleted layers are unparented where they are (like After Effects).let comp = s.project.comp(cid).ok_or(crate::EngineError::NoComp)?;let orphans: Vec<LayerId> = comp.layers.iter().filter(|l| !ids.contains(&l.id) && l.parent.is_some_and(|p| ids.contains(&p))).map(|l| l.id).collect();@@ -236,11 +253,7 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {st.selected_props.clear();st.selected_keys.clear();Ok(())- })?;- // A removed layer may have been the edited one: end that session before another command- // can reuse it. Undo restores a layer as a new editor, never by reviving the old IME session.- s.sanitize_state();- Ok(json!(ids.len()))+ })}fn clear_clipboards(s: &mut Session) {diff --git a/crates/engine/src/footage_reload.rs b/crates/engine/src/footage_reload.rsindex 9b3c135a8..75fd0f936 100644--- a/crates/engine/src/footage_reload.rs+++ b/crates/engine/src/footage_reload.rs@@ -159,6 +159,14 @@ fn reload(s: &mut Session, ids: &[ItemId], undoable: bool) -> crate::Result<(usi}}let n = updates.len();+ apply_reloads(s, updates, undoable)?;+ forget(s, &paths);+ Ok((n, failed))+}++/// Puts reloaded footage into the project: an undoable edit, or (not undoable) a disk change+/// that leaves the project's dirty state as it was.+fn apply_reloads(s: &mut Session, updates: Vec<(ItemId, Footage)>, undoable: bool) -> crate::Result<()> {if undoable {s.edit("Reload Footage", None, |proj, _| {for (i, f) in updates {@@ -188,8 +196,7 @@ fn reload(s: &mut Session, ids: &[ItemId], undoable: bool) -> crate::Result<(usi}}}- forget(s, &paths);- Ok((n, failed))+ Ok(())}/// Make the media layer and the layer cache let go of `paths`, so renders read them again.diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rsindex 0730e4442..1f2e32115 100644--- a/crates/text/src/layout.rs+++ b/crates/text/src/layout.rs@@ -20,7 +20,7 @@ use unicode_bidi::{BidiInfo, Level};use effectcraft_keyframe::{OpenType, text_doc::paragraph_ranges};-use crate::fonts::{self, FaceId, Resolved};+use crate::fonts::{self, FaceId, Resolved, VMetrics};#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]pub enum Caps {@@ -597,243 +597,249 @@ fn run_at(runs: &[(Range<usize>, TextStyle)], b: usize) -> usize {}/// Lay out one paragraph (no newlines) whose text starts at byte `base` of the whole string.-fn paragraph(- text: &str,+/// Margins (left, right) of a paragraph's first or later lines.+fn margins_for(para: &ParagraphStyle, first: bool) -> (f32, f32) {+ let fi = if first { para.indent_first } else { 0.0 };+ if para.rtl == Some(true) { (para.indent_end, para.indent_start + fi) } else { (para.indent_start + fi, para.indent_end) }+}++/// The width a line may fill (`None` for point text).+fn avail_for(para: &ParagraphStyle, width: Option<f32>, first: bool) -> Option<f32> {+ let (l, r) = margins_for(para, first);+ width.map(|w| (w - l - r).max(1.0))+}++/// The alignment of a line, justified lines that cannot stretch falling back to `justify_last`.+fn align_for(para: &ParagraphStyle, width: Option<f32>, last: bool) -> Align {+ if (last || width.is_none()) && para.align == Align::Justify {+ if width.is_none() && para.justify_last == Align::Justify { Align::Left } else { para.justify_last }+ } else {+ para.align+ }+}++fn style_metrics(primaries: &[Resolved], runs: &[(Range<usize>, TextStyle)], si: usize) -> VMetrics {+ fonts::face(primaries[si].face).metrics(runs[si].1.glyph_size())+}++/// A char's shaping inputs: (byte, char, shaped char, face, rtl, form, run).+type CharInfo = (usize, char, char, FaceId, bool, Form, usize);++/// The glyphs of one line in visual order, where its pen ended, the extent of each cluster by+/// byte, and the underline span.+struct Placed {+ glyphs: Vec<Glyph>,+ pen: f32,+ extents: HashMap<usize, (f32, f32, bool)>,+ underline: Option<(f32, f32)>,+}++/// A paragraph shaped and measured, ready to be broken into lines.+struct Para<'a> {+ text: &'a str,base: usize,- runs: &[(Range<usize>, TextStyle)],- primaries: &[Resolved],- variation_ids: &[u32],- para: &ParagraphStyle,+ runs: &'a [(Range<usize>, TextStyle)],+ primaries: &'a [Resolved],+ variation_ids: &'a [u32],+ para: &'a ParagraphStyle,width: Option<f32>,-) -> Vec<ParaLine> {- let rtl_para = para.rtl == Some(true);- let margins_for = |first: bool| -> (f32, f32) {- let fi = if first { para.indent_first } else { 0.0 };- if rtl_para { (para.indent_end, para.indent_start + fi) } else { (para.indent_start + fi, para.indent_end) }- };- let avail_for = |first: bool| -> Option<f32> {- let (l, r) = margins_for(first);- width.map(|w| (w - l - r).max(1.0))- };- let style_metrics = |si: usize| {- let st = &runs[si].1;- fonts::face(primaries[si].face).metrics(st.glyph_size())- };- let eff_align = |last: bool| -> Align {- if (last || width.is_none()) && para.align == Align::Justify {- if width.is_none() && para.justify_last == Align::Justify { Align::Left } else { para.justify_last }- } else {- para.align+ bidi: BidiInfo<'a>,+ base_rtl: bool,+ chars: Vec<CharInfo>,+ items: Vec<Item>,+ /// Advance of the glyphs at each byte, and prefix sums over it.+ char_adv: Vec<f32>,+ prefix_adv: Vec<f64>,+ previous_non_ws: Vec<usize>,+}++impl<'a> Para<'a> {+ fn new(+ text: &'a str,+ base: usize,+ runs: &'a [(Range<usize>, TextStyle)],+ primaries: &'a [Resolved],+ variation_ids: &'a [u32],+ para: &'a ParagraphStyle,+ width: Option<f32>,+ ) -> Self {+ let default_level = para.rtl.map(|r| if r { Level::rtl() } else { Level::ltr() });+ let bidi = BidiInfo::new(text, default_level);+ let base_rtl = bidi.paragraphs[0].level.is_rtl();+ let chars = char_forms(text, base, runs, primaries, &bidi);+ let items = build_items(text, &chars, runs);+ // Prefix widths and the preceding non-whitespace boundary make candidate line widths O(1).+ // Every-line composition evaluates O(n²) candidate breaks; summing each candidate's bytes+ // or rescanning its trailing whitespace would otherwise add another factor of text length.+ let mut char_adv = vec![0.0f32; text.len() + 1];+ for it in &items {+ for g in &it.glyphs {+ char_adv[g.cluster.min(text.len())] += g.adv + g.pre;+ }}- };- if text.is_empty() {- let si = run_at(runs, base);- let pm = style_metrics(si);- return vec![ParaLine {- range: base..base,- glyphs: vec![],- carets: vec![(base, 0.0)],- content: 0.0,- left_trim: 0.0,- hang: (0.0, 0.0),- ascent: pm.ascent,- descent: pm.descent,- advance: runs[si].1.line_advance(),- align: eff_align(true),- avail: avail_for(true),- margins: margins_for(true),- underline: None,- }];- }- let default_level = para.rtl.map(|r| if r { Level::rtl() } else { Level::ltr() });- let bidi = BidiInfo::new(text, default_level);- let pinfo = &bidi.paragraphs[0];- let base_rtl = pinfo.level.is_rtl();- // per char: (byte, char, shaped char, face, rtl, form, run)- let chars: Vec<(usize, char, char, FaceId, bool, Form, usize)> = text- .char_indices()- .map(|(b, c)| {- let si = run_at(runs, base + b);- let style = &runs[si].1;- let primary = primaries[si].face;- let face_of = |ch: char| if ch.is_whitespace() { primary } else { fonts::fallback_for(ch, primary) };- let all_small = style.opentype.all_small_caps && style.caps != Caps::All;- let small = (style.caps == Caps::Small || all_small) && c.is_lowercase();- let small_cap = all_small && c.is_uppercase();- let (sc, mut form) = match style.caps {- Caps::All => (upper_single(c), Form::Normal),- _ if small && feature_substitutes(face_of(c), b"smcp", c) => (c, Form::TrueSmall),- _ if small_cap && feature_substitutes(face_of(c), b"c2sc", c) => (c, Form::TrueSmall),- _ if small => (upper_single(c), Form::FauxSmall),- _ if small_cap => (c, Form::FauxSmall),- _ => (c, Form::Normal),- };- let face = face_of(sc);- if form == Form::Normal && style.script != Script::Normal && !sc.is_whitespace() {- let tag = if style.script == Script::Sub { b"subs" } else { b"sups" };- if feature_substitutes(face, tag, sc) {- form = Form::TrueScript;- }+ let mut prefix_adv = vec![0.0f64; text.len() + 1];+ for i in 0..text.len() {+ prefix_adv[i + 1] = prefix_adv[i] + f64::from(char_adv[i]);+ }+ let mut previous_non_ws = vec![0usize; text.len() + 1];+ let mut non_ws_end = 0usize;+ for (b, c) in text.char_indices() {+ previous_non_ws[b] = non_ws_end;+ if !c.is_whitespace() {+ non_ws_end = b + c.len_utf8();}- (b, c, sc, face, bidi.levels[b].is_rtl(), form, si)- })- .collect();- // items: runs of equal (face, rtl, small, style)- let mut items: Vec<Item> = Vec::new();- let mut i = 0;- while i < chars.len() {- let key =- |c: &(usize, char, char, FaceId, bool, Form, usize)| (c.3, c.4, c.5, c.6, runs.get(c.6).is_some_and(|run| run.1.vertical) && crate::is_cjk(c.1));- let k0 = key(&chars[i]);- let mut j = i + 1;- while j < chars.len() && key(&chars[j]) == k0 {- j += 1;+ previous_non_ws[b + c.len_utf8()] = non_ws_end;}- let (face, rtl, form, si, _) = k0;- let style = &runs[si].1;- let sub: Vec<(usize, char, char)> = chars[i..j].iter().map(|c| (c.0, c.1, c.2)).collect();- let size = match form {- Form::FauxSmall => style.glyph_size() * SMALL_CAPS_SCALE,- Form::TrueScript => style.size,- _ => style.glyph_size(),- };- let mut glyphs = shape_item(&sub, rtl, face, size, style, si, form);- space_item(&mut glyphs, style, text, true);- let end = if j < chars.len() { chars[j].0 } else { text.len() };- items.push(Item { range: chars[i].0..end, rtl, glyphs });- i = j;+ Para { text, base, runs, primaries, variation_ids, para, width, bidi, base_rtl, chars, items, char_adv, prefix_adv, previous_non_ws }}- // advance per char byte (cluster start)- let mut char_adv = vec![0.0f32; text.len() + 1];- for it in &items {- for g in &it.glyphs {- char_adv[g.cluster.min(text.len())] += g.adv + g.pre;- }++ fn range_w(&self, r: Range<usize>) -> f32 {+ (self.prefix_adv[r.end] - self.prefix_adv[r.start]) as f32}- // Prefix widths and the preceding non-whitespace boundary make candidate line widths O(1).- // Every-line composition evaluates O(n²) candidate breaks; summing each candidate's bytes- // or rescanning its trailing whitespace would otherwise add another factor of text length.- let mut prefix_adv = vec![0.0f64; text.len() + 1];- for i in 0..text.len() {- prefix_adv[i + 1] = prefix_adv[i] + f64::from(char_adv[i]);- }- let mut previous_non_ws = vec![0usize; text.len() + 1];- let mut non_ws_end = 0usize;- for (b, c) in text.char_indices() {- previous_non_ws[b] = non_ws_end;- if !c.is_whitespace() {- non_ws_end = b + c.len_utf8();- }- previous_non_ws[b + c.len_utf8()] = non_ws_end;++ fn trailing_ws(&self, r: &Range<usize>) -> (usize, f32) {+ let end = self.previous_non_ws[r.end].max(r.start).min(r.end);+ (end, (self.prefix_adv[r.end] - self.prefix_adv[end]) as f32)}- let range_w = |r: Range<usize>| -> f32 { (prefix_adv[r.end] - prefix_adv[r.start]) as f32 };- let trailing_ws = |r: &Range<usize>| -> (usize, f32) {- let end = previous_non_ws[r.end].max(r.start).min(r.end);- (end, (prefix_adv[r.end] - prefix_adv[end]) as f32)- };- // Hanging punctuation widths (left, right) of a line's content.- let hang_of = |r: &Range<usize>, ce: usize| -> (f32, f32) {- if !para.hanging || width.is_none() || r.start >= ce {++ /// Hanging punctuation widths (left, right) of a line's content.+ fn hang_of(&self, r: &Range<usize>, ce: usize) -> (f32, f32) {+ if !self.para.hanging || self.width.is_none() || r.start >= ce {return (0.0, 0.0);}- let first = text[r.start..ce].chars().next().filter(|c| is_hanging_open(*c)).map_or(0.0, |_| char_adv[r.start]);- let last = text[r.start..ce].char_indices().next_back().filter(|(_, c)| is_hanging_close(*c)).map_or(0.0, |(b, _)| char_adv[r.start + b]);+ let first = self.text[r.start..ce].chars().next().filter(|c| is_hanging_open(*c)).map_or(0.0, |_| self.char_adv[r.start]);+ let last = self.text[r.start..ce].char_indices().next_back().filter(|(_, c)| is_hanging_close(*c)).map_or(0.0, |(b, _)| self.char_adv[r.start + b]);(first, last)- };- let fits_w = |r: &Range<usize>| -> f32 {- let (ce, _) = trailing_ws(r);- let (hl, hr) = hang_of(r, ce);- range_w(r.start..ce) - hl - hr- };- // line breaking- let mut ranges: Vec<Range<usize>> = Vec::new();- match width {- None => ranges.push(0..text.len()),- Some(_) => {- let opps: Vec<usize> = unicode_linebreak::linebreaks(text).map(|(p, _)| p).collect();- let avail = |line: usize| avail_for(line == 0).unwrap_or(f32::MAX);- if para.every_line && opps.len() > 1 && opps.len() <= 1500 {- // Minimise the summed squared slack of every line but the last.- let nodes: Vec<usize> = std::iter::once(0).chain(opps.iter().copied()).collect();- let m = nodes.len();- let mut best = vec![(f32::INFINITY, 0usize); m];- best[0] = (0.0, 0);- for j in 1..m {- for i in (0..j).rev() {- if !best[i].0.is_finite() {- continue;- }- let r = nodes[i]..nodes[j];- let w = fits_w(&r);- let maxw = avail(usize::from(i != 0));- let over = w > maxw;- if over && i + 1 != j {- break;- }- let slack = maxw - w;- let cost = if over {- 1e12 + w- } else if j == m - 1 {- 0.0- } else {- slack * slack- };- let total = best[i].0 + cost;- if total < best[j].0 {- best[j] = (total, i);- }- }+ }++ fn fits_w(&self, r: &Range<usize>) -> f32 {+ let (ce, _) = self.trailing_ws(r);+ let (hl, hr) = self.hang_of(r, ce);+ self.range_w(r.start..ce) - hl - hr+ }++ fn line_avail(&self, line: usize) -> f32 {+ avail_for(self.para, self.width, line == 0).unwrap_or(f32::MAX)+ }++ /// The byte ranges of the lines, for the wrap width.+ fn break_ranges(&self) -> Vec<Range<usize>> {+ if self.width.is_none() {+ return std::iter::once(0..self.text.len()).collect();+ }+ let opps: Vec<usize> = unicode_linebreak::linebreaks(self.text).map(|(p, _)| p).collect();+ let mut ranges = if self.para.every_line && opps.len() > 1 && opps.len() <= 1500 { self.optimal_breaks(&opps) } else { self.greedy_breaks(opps) };+ ranges.retain(|r| !r.is_empty());+ if ranges.is_empty() {+ ranges.push(0..self.text.len());+ }+ ranges+ }++ /// Minimises the summed squared slack of every line but the last.+ fn optimal_breaks(&self, opps: &[usize]) -> Vec<Range<usize>> {+ let nodes: Vec<usize> = std::iter::once(0).chain(opps.iter().copied()).collect();+ let m = nodes.len();+ let mut best = vec![(f32::INFINITY, 0usize); m];+ best[0] = (0.0, 0);+ for j in 1..m {+ for i in (0..j).rev() {+ if !best[i].0.is_finite() {+ continue;}- let mut j = m - 1;- while j > 0 {- let i = best[j].1;- ranges.push(nodes[i]..nodes[j]);- j = i;+ let r = nodes[i]..nodes[j];+ let w = self.fits_w(&r);+ let maxw = self.line_avail(usize::from(i != 0));+ let over = w > maxw;+ if over && i + 1 != j {+ break;}- ranges.reverse();- } else {- let mut start = 0usize;- let mut last_ok: Option<usize> = None;- for p in opps {- loop {- let w = fits_w(&(start..p));- if w <= avail(ranges.len()) || last_ok.is_none() {- last_ok = Some(p);- break;- }- let Some(b) = last_ok.take() else { break };- ranges.push(start..b);- start = b;- }+ let slack = maxw - w;+ let cost = if over {+ 1e12 + w+ } else if j == m - 1 {+ 0.0+ } else {+ slack * slack+ };+ let total = best[i].0 + cost;+ if total < best[j].0 {+ best[j] = (total, i);}- ranges.push(start..text.len());}- ranges.retain(|r| !r.is_empty());- if ranges.is_empty() {- ranges.push(0..text.len());+ }+ let mut ranges = Vec::new();+ let mut j = m - 1;+ while j > 0 {+ let i = best[j].1;+ ranges.push(nodes[i]..nodes[j]);+ j = i;+ }+ ranges.reverse();+ ranges+ }++ /// Breaks at each opportunity that still fits, else at the last one that did.+ fn greedy_breaks(&self, opps: Vec<usize>) -> Vec<Range<usize>> {+ let mut ranges = Vec::new();+ let mut start = 0usize;+ let mut last_ok: Option<usize> = None;+ for p in opps {+ loop {+ let w = self.fits_w(&(start..p));+ if w <= self.line_avail(ranges.len()) || last_ok.is_none() {+ last_ok = Some(p);+ break;+ }+ let Some(b) = last_ok.take() else { break };+ ranges.push(start..b);+ start = b;}}+ ranges.push(start..self.text.len());+ ranges}- let nlines = ranges.len();- let mut out = Vec::new();- for (li, r) in ranges.into_iter().enumerate() {- let last = li + 1 == nlines;- let align = eff_align(last);- let avail = avail_for(li == 0);- let (ce, tw) = trailing_ws(&r);- let hang = hang_of(&r, ce);- let content = range_w(r.start..ce);++ /// The line over byte range `r`: the `li`-th of the paragraph, `last` if it is the final one.+ fn place_line(&self, li: usize, r: Range<usize>, last: bool) -> ParaLine {+ let align = align_for(self.para, self.width, last);+ let avail = avail_for(self.para, self.width, li == 0);+ let (ce, tw) = self.trailing_ws(&r);+ let hang = self.hang_of(&r, ce);+ let content = self.range_w(r.start..ce);// justificationlet mut space_extra = 0.0;if align == Align::Justify&& let Some(maxw) = avail{- let spaces = text[r.start..ce].chars().filter(|c| *c == ' ').count();+ let spaces = self.text[r.start..ce].chars().filter(|c| *c == ' ').count();if spaces > 0 {space_extra = ((maxw - (content - hang.0 - hang.1)) / spaces as f32).max(0.0);}}- let (levels, vruns) = bidi.visual_runs(pinfo, r.clone());+ let placed = self.place_glyphs(&r, space_extra, ce);+ let carets = self.carets(&r, &placed.extents, placed.pen);+ let (asc, desc, adv) = self.line_metrics(&r, &placed.glyphs);+ let content_w = if space_extra > 0.0 { avail.map_or(content, |a| a + hang.0 + hang.1) } else { content };+ ParaLine {+ range: self.base + r.start..self.base + r.end,+ glyphs: placed.glyphs,+ carets,+ content: content_w,+ left_trim: if self.base_rtl { tw } else { 0.0 },+ hang,+ ascent: asc,+ descent: desc,+ advance: adv,+ align,+ avail,+ margins: margins_for(self.para, li == 0),+ underline: placed.underline,+ }+ }++ fn place_glyphs(&self, r: &Range<usize>, space_extra: f32, ce: usize) -> Placed {+ let (levels, vruns) = self.bidi.visual_runs(&self.bidi.paragraphs[0], r.clone());let mut pen = 0.0f32;let mut glyphs = Vec::new();let mut extents: HashMap<usize, (f32, f32, bool)> = HashMap::new();@@ -841,15 +847,15 @@ fn paragraph(for run in vruns {let rtl = levels[run.start].is_rtl();// Items are ordered and disjoint: binary-search both ends of the overlapping slice.- let run_limit = items.partition_point(|item| item.range.start < run.end);- let run_first = items[..run_limit].partition_point(|item| item.range.end <= run.start);+ let run_limit = self.items.partition_point(|item| item.range.start < run.end);+ let run_first = self.items[..run_limit].partition_point(|item| item.range.end <= run.start);let mut idx: Vec<usize> = (run_first..run_limit).collect();if rtl {idx.reverse();}for k in idx {- for g in items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) {- let st = &runs[g.run].1;+ for g in self.items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) {+ let st = &self.runs[g.run].1;let x0 = pen;pen += g.pre;glyphs.push(Glyph {@@ -858,16 +864,16 @@ fn paragraph(x: pen + g.dx,y: -g.dy - g.rise,size: g.size,- cluster: base + g.cluster,- synth_bold: primaries[g.run].synth_bold || st.faux_bold,- synth_italic: primaries[g.run].synth_italic || st.faux_italic,+ cluster: self.base + g.cluster,+ synth_bold: self.primaries[g.run].synth_bold || st.faux_bold,+ synth_italic: self.primaries[g.run].synth_italic || st.faux_italic,h_scale: st.h_scale,v_scale: st.v_scale,run: g.run,- variations: variation_ids[g.run],+ variations: self.variation_ids[g.run],});pen += g.adv;- if space_extra > 0.0 && text[g.cluster..].starts_with(' ') && g.cluster < ce {+ if space_extra > 0.0 && self.text[g.cluster..].starts_with(' ') && g.cluster < ce {pen += space_extra;}if st.underline && g.cluster < ce {@@ -875,17 +881,21 @@ fn paragraph(u.0 = u.0.min(x0);u.1 = u.1.max(pen);}- let e = extents.entry(g.cluster).or_insert((x0, pen, items[k].rtl));+ let e = extents.entry(g.cluster).or_insert((x0, pen, self.items[k].rtl));e.0 = e.0.min(x0);e.1 = e.1.max(pen);}}}- // Caret stops for each char boundary in the line.+ Placed { glyphs, pen, extents, underline }+ }++ /// Caret stops at each char boundary of the line, and at its end.+ fn carets(&self, r: &Range<usize>, extents: &HashMap<usize, (f32, f32, bool)>, pen: f32) -> Vec<(usize, f32)> {let mut carets = Vec::new();let mut cluster_starts: Vec<usize> = extents.keys().copied().collect();cluster_starts.sort_unstable();- let char_bytes: Vec<usize> = text[r.clone()].char_indices().map(|(b, _)| r.start + b).collect();+ let char_bytes: Vec<usize> = self.text[r.clone()].char_indices().map(|(b, _)| r.start + b).collect();let mut char_index = 0usize;for (ci, &cs) in cluster_starts.iter().enumerate() {let (x0, x1, rtl) = extents[&cs];@@ -901,11 +911,11 @@ fn paragraph(for (mi, b) in char_bytes[begin..char_index].iter().enumerate() {let f = mi as f32 / count;let x = if rtl { x1 - (x1 - x0) * f } else { x0 + (x1 - x0) * f };- carets.push((base + b, x));+ carets.push((self.base + b, x));}}// end of line caret- let end_x = match chars.iter().rev().find(|c| c.0 < r.end && c.0 >= r.start) {+ let end_x = match self.chars.iter().rev().find(|c| c.0 < r.end && c.0 >= r.start) {Some(c) => {let cs = cluster_starts.iter().rev().find(|s| **s <= c.0).copied();match cs.and_then(|s| extents.get(&s)) {@@ -921,54 +931,134 @@ fn paragraph(}None => 0.0,};- carets.push((base + r.end, end_x));+ carets.push((self.base + r.end, end_x));carets.sort_by_key(|c| c.0);carets.dedup_by_key(|c| c.0);- // Line metrics: the tallest face and the largest leading on the line.+ carets+ }++ /// Ascent, descent and advance of the line: the tallest face and the largest leading on it.+ fn line_metrics(&self, r: &Range<usize>, glyphs: &[Glyph]) -> (f32, f32, f32) {let (mut asc, mut desc, mut adv) = (0.0f32, 0.0f32, 0.0f32);- let char_start = chars.partition_point(|c| c.0 < r.start);- let char_end = chars.partition_point(|c| c.0 < r.end);- let mut seen: Vec<usize> = chars[char_start..char_end].iter().map(|c| c.6).collect();+ let char_start = self.chars.partition_point(|c| c.0 < r.start);+ let char_end = self.chars.partition_point(|c| c.0 < r.end);+ let mut seen: Vec<usize> = self.chars[char_start..char_end].iter().map(|c| c.6).collect();seen.sort_unstable();seen.dedup();if seen.is_empty() {- seen.push(chars.first().map_or(0, |c| c.6));+ seen.push(self.chars.first().map_or(0, |c| c.6));}for &si in &seen {- let m = style_metrics(si);- let rise = runs[si].1.rise();+ let m = style_metrics(self.primaries, self.runs, si);+ let rise = self.runs[si].1.rise();asc = asc.max(m.ascent + rise.max(0.0));desc = desc.max(m.descent - rise.min(0.0));- adv = adv.max(runs[si].1.line_advance());+ adv = adv.max(self.runs[si].1.line_advance());}- for g in &glyphs {- if g.face != primaries[g.run].face {+ for g in glyphs {+ if g.face != self.primaries[g.run].face {let m = fonts::face(g.face).metrics(g.size);asc = asc.max(m.ascent);desc = desc.max(m.descent);}}- let content_w = if space_extra > 0.0 { avail.map_or(content, |a| a + hang.0 + hang.1) } else { content };- out.push(ParaLine {- range: base + r.start..base + r.end,- glyphs,- carets,- content: content_w,- left_trim: if base_rtl { tw } else { 0.0 },- hang,- ascent: asc,- descent: desc,- advance: adv,- align,- avail,- margins: margins_for(li == 0),- underline,- });+ (asc, desc, adv)+ }+}++/// Each char with its shaped form, face, direction and run.+fn char_forms(text: &str, base: usize, runs: &[(Range<usize>, TextStyle)], primaries: &[Resolved], bidi: &BidiInfo) -> Vec<CharInfo> {+ text.char_indices()+ .map(|(b, c)| {+ let si = run_at(runs, base + b);+ let style = &runs[si].1;+ let primary = primaries[si].face;+ let face_of = |ch: char| if ch.is_whitespace() { primary } else { fonts::fallback_for(ch, primary) };+ let all_small = style.opentype.all_small_caps && style.caps != Caps::All;+ let small = (style.caps == Caps::Small || all_small) && c.is_lowercase();+ let small_cap = all_small && c.is_uppercase();+ let (sc, mut form) = match style.caps {+ Caps::All => (upper_single(c), Form::Normal),+ _ if small && feature_substitutes(face_of(c), b"smcp", c) => (c, Form::TrueSmall),+ _ if small_cap && feature_substitutes(face_of(c), b"c2sc", c) => (c, Form::TrueSmall),+ _ if small => (upper_single(c), Form::FauxSmall),+ _ if small_cap => (c, Form::FauxSmall),+ _ => (c, Form::Normal),+ };+ let face = face_of(sc);+ if form == Form::Normal && style.script != Script::Normal && !sc.is_whitespace() {+ let tag = if style.script == Script::Sub { b"subs" } else { b"sups" };+ if feature_substitutes(face, tag, sc) {+ form = Form::TrueScript;+ }+ }+ (b, c, sc, face, bidi.levels[b].is_rtl(), form, si)+ })+ .collect()+}++/// Runs of chars with the same face, direction, form, run and CJK vertical flag, shaped as one.+fn build_items(text: &str, chars: &[CharInfo], runs: &[(Range<usize>, TextStyle)]) -> Vec<Item> {+ let key = |c: &CharInfo| (c.3, c.4, c.5, c.6, runs.get(c.6).is_some_and(|run| run.1.vertical) && crate::is_cjk(c.1));+ let mut items: Vec<Item> = Vec::new();+ let mut i = 0;+ while i < chars.len() {+ let k0 = key(&chars[i]);+ let mut j = i + 1;+ while j < chars.len() && key(&chars[j]) == k0 {+ j += 1;+ }+ let (face, rtl, form, si, _) = k0;+ let style = &runs[si].1;+ let sub: Vec<(usize, char, char)> = chars[i..j].iter().map(|c| (c.0, c.1, c.2)).collect();+ let size = match form {+ Form::FauxSmall => style.glyph_size() * SMALL_CAPS_SCALE,+ Form::TrueScript => style.size,+ _ => style.glyph_size(),+ };+ let mut glyphs = shape_item(&sub, rtl, face, size, style, si, form);+ space_item(&mut glyphs, style, text, true);+ let end = if j < chars.len() { chars[j].0 } else { text.len() };+ items.push(Item { range: chars[i].0..end, rtl, glyphs });+ i = j;}- out+ items+}++fn paragraph(+ text: &str,+ base: usize,+ runs: &[(Range<usize>, TextStyle)],+ primaries: &[Resolved],+ variation_ids: &[u32],+ para: &ParagraphStyle,+ width: Option<f32>,+) -> Vec<ParaLine> {+ if text.is_empty() {+ let si = run_at(runs, base);+ let pm = style_metrics(primaries, runs, si);+ return vec![ParaLine {+ range: base..base,+ glyphs: vec![],+ carets: vec![(base, 0.0)],+ content: 0.0,+ left_trim: 0.0,+ hang: (0.0, 0.0),+ ascent: pm.ascent,+ descent: pm.descent,+ advance: runs[si].1.line_advance(),+ align: align_for(para, width, true),+ avail: avail_for(para, width, true),+ margins: margins_for(para, true),+ underline: None,+ }];+ }+ let p = Para::new(text, base, runs, primaries, variation_ids, para, width);+ let ranges = p.break_ranges();+ let nlines = ranges.len();+ ranges.into_iter().enumerate().map(|(li, r)| p.place_line(li, r, li + 1 == nlines)).collect()}-/// Lay out `text` (paragraphs separated by CR, LF or CRLF) in one style.pub fn layout_uncached(text: &str, style: &TextStyle, para: &ParagraphStyle) -> Layout {layout_rich_uncached(text, &[(0..text.len(), style.clone())], std::slice::from_ref(para))}@@ -992,10 +1082,8 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], paralet primaries: Vec<Resolved> = runs.iter().map(|(_, s)| fonts::resolve(&s.family, &s.style)).collect();// A named instance of a variable font (`Figtree` `Black`, or `Figtree-Black`) sets the base// axis values; axes set explicitly in the style keep theirs.- let instanced: Vec<(Range<usize>, TextStyle)>;- let runs = if primaries.iter().any(|p| p.instance.is_some()) {- instanced = runs- .iter()+ let instanced = primaries.iter().any(|p| p.instance.is_some()).then(|| {+ runs.iter().zip(&primaries).map(|((r, s), p)| {let base = fonts::instance_variations(p);@@ -1005,16 +1093,12 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para}(r.clone(), s)})- .collect();- &instanced[..]- } else {- runs- };+ .collect::<Vec<_>>()+ });+ let runs = instanced.as_deref().unwrap_or(runs);// A location that cannot be interned would outline at the default; shape there too.- let cleared: Vec<(Range<usize>, TextStyle)>;- let runs = if runs.iter().any(|(_, s)| !s.variations.is_empty() && crate::variable::intern(&s.variations) == 0) {- cleared = runs- .iter()+ let cleared = runs.iter().any(|(_, s)| !s.variations.is_empty() && crate::variable::intern(&s.variations) == 0).then(|| {+ runs.iter().map(|(r, s)| {let mut s = s.clone();if crate::variable::intern(&s.variations) == 0 {@@ -1022,11 +1106,9 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para}(r.clone(), s)})- .collect();- &cleared[..]- } else {- runs- };+ .collect::<Vec<_>>()+ });+ let runs = cleared.as_deref().unwrap_or(runs);let variation_ids: Vec<u32> = runs.iter().map(|(_, s)| crate::variable::intern(&s.variations)).collect();let mut lay = Layout { missing_font: primaries.iter().any(|p| p.missing), text_len: text.len(), ..Default::default() };let mut plines: Vec<(usize, ParaLine)> = Vec::new();@@ -1047,17 +1129,7 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para}baseline += adv;}- let shown = pl.content - pl.hang.0 - pl.hang.1;- let (ml, mr) = pl.margins;- let shift = match (pl.avail, pl.align) {- (None, Align::Left | Align::Justify) => ml,- (None, Align::Center) => -shown / 2.0 + (ml - mr) / 2.0,- (None, Align::Right) => -shown - mr,- (Some(_), Align::Left | Align::Justify) => ml,- (Some(a), Align::Center) => ml + (a - shown) / 2.0,- (Some(a), Align::Right) => ml + a - shown,- } - pl.left_trim- - pl.hang.0;+ let shift = line_shift(&pl);let g0 = lay.glyphs.len();lay.glyphs.extend(pl.glyphs.into_iter().map(|mut g| {g.x += shift;@@ -1086,6 +1158,27 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], parafor i in 0..lay.lines.len() {lay.lines[i].para_end = lay.lines.get(i + 1).is_none_or(|n| n.para != lay.lines[i].para);}+ set_bounds(&mut lay, width);+ lay+}++/// Horizontal shift of a line from its paragraph's alignment, margins and hanging punctuation.+fn line_shift(pl: &ParaLine) -> f32 {+ let shown = pl.content - pl.hang.0 - pl.hang.1;+ let (ml, mr) = pl.margins;+ let shift = match (pl.avail, pl.align) {+ (None, Align::Left | Align::Justify) => ml,+ (None, Align::Center) => -shown / 2.0 + (ml - mr) / 2.0,+ (None, Align::Right) => -shown - mr,+ (Some(_), Align::Left | Align::Justify) => ml,+ (Some(a), Align::Center) => ml + (a - shown) / 2.0,+ (Some(a), Align::Right) => ml + a - shown,+ };+ shift - pl.left_trim - pl.hang.0+}++/// The layout's bounds: the lines' horizontal extent (and the wrap width), and their vertical extent.+fn set_bounds(lay: &mut Layout, width: Option<f32>) {let (mut x0, mut x1) = (f32::MAX, f32::MIN);for l in &lay.lines {x0 = x0.min(l.x);@@ -1098,7 +1191,6 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], paraif let (Some(first), Some(last)) = (lay.lines.first(), lay.lines.last()) {lay.bounds = [x0, first.baseline - first.ascent, x1.max(x0), last.baseline + last.descent];}- lay}fn cache() -> &'static Mutex<HashMap<u64, (u64, Arc<Layout>)>> {