Calculate minimum and maximum content width

Author: wfdewith

parley/src/layout/data.rs

@@ -195,6 +195,8 @@ pub(crate) struct LayoutData<B: Brush> {
     pub(crate) text_len: usize,
     pub(crate) width: f32,
     pub(crate) full_width: f32,
+    pub(crate) min_content_width: f32,
+    pub(crate) max_content_width: f32,
     pub(crate) height: f32,
     pub(crate) fonts: Vec<Font>,
     pub(crate) coords: Vec<i16>,
@@ -223,6 +225,8 @@ impl<B: Brush> Default for LayoutData<B> {
             text_len: 0,
             width: 0.,
             full_width: 0.,
+            min_content_width: 0.,
+            max_content_width: 0.,
             height: 0.,
             fonts: Vec::new(),
             coords: Vec::new(),
@@ -246,6 +250,8 @@ impl<B: Brush> LayoutData<B> {
         self.text_len = 0;
         self.width = 0.;
         self.full_width = 0.;
+        self.min_content_width = 0.;
+        self.max_content_width = 0.;
         self.height = 0.;
         self.fonts.clear();
         self.coords.clear();
@@ -444,6 +450,11 @@ impl<B: Brush> LayoutData<B> {
     }
 
     pub(crate) fn finish(&mut self) {
+        self.apply_spacing();
+        self.calculate_content_widths();
+    }
+
+    fn apply_spacing(&mut self) {
         for run in &self.runs {
             let word = run.word_spacing;
             let letter = run.letter_spacing;
@@ -470,4 +481,43 @@ impl<B: Brush> LayoutData<B> {
             }
         }
     }
+
+    fn calculate_content_widths(&mut self) {
+        let mut max_width = 0.0;
+        for item in &self.items {
+            match item.kind {
+                LayoutItemKind::TextRun => {
+                    let run = &self.runs[item.index];
+                    let mut min_width = 0.0;
+                    let mut trailing_whitespace = 0.0;
+                    for cluster in &self.clusters[run.cluster_range.clone()] {
+                        let boundary = cluster.info.boundary();
+                        if matches!(boundary, Boundary::Line | Boundary::Mandatory) {
+                            self.min_content_width =
+                                self.min_content_width.max(min_width - trailing_whitespace);
+                            min_width = 0.0;
+                            if boundary == Boundary::Mandatory {
+                                max_width = 0.0;
+                            }
+                        }
+                        min_width += cluster.advance;
+                        trailing_whitespace = if cluster.info.whitespace().is_space_or_nbsp() {
+                            cluster.advance
+                        } else {
+                            0.0
+                        };
+                    }
+                    self.min_content_width =
+                        self.min_content_width.max(min_width - trailing_whitespace);
+                    max_width += run.advance - trailing_whitespace;
+                }
+                LayoutItemKind::InlineBox => {
+                    let ibox = &self.inline_boxes[item.index];
+                    self.min_content_width = self.min_content_width.max(ibox.width);
+                    max_width += ibox.width;
+                }
+            }
+            self.max_content_width = self.max_content_width.max(max_width);
+        }
+    }
 }

parley/src/layout/mod.rs

@@ -81,6 +81,18 @@ impl<B: Brush> Layout<B> {
         self.data.full_width
     }
 
+    /// Returns the minimum content width of the layout. This is the width of the layout if _all_
+    /// soft line-breaking opportunities are taken.
+    pub fn min_content_width(&self) -> f32 {
+        self.data.min_content_width
+    }
+
+    /// Returns the maximum content width of the layout. This is the width of the layout if _no_
+    /// soft line-breaking opportunities are taken.
+    pub fn max_content_width(&self) -> f32 {
+        self.data.max_content_width
+    }
+
     /// Returns the height of the layout.
     pub fn height(&self) -> f32 {
         self.data.height

parley/src/tests/test_basic.rs

@@ -127,3 +127,39 @@ fn trailing_whitespace() {
 
     env.check_layout_snapshot(&layout);
 }
+
+#[test]
+fn content_widths() {
+    let mut env = testenv!();
+
+    let text = "Hello world!\nLonger line with a looooooooong word.";
+    let mut builder = env.builder(text);
+
+    let mut layout = builder.build(text);
+
+    layout.break_all_lines(Some(layout.min_content_width()));
+    layout.align(None, Alignment::Start, false);
+    env.with_name("min").check_layout_snapshot(&layout);
+
+    layout.break_all_lines(Some(layout.max_content_width()));
+    layout.align(None, Alignment::Start, false);
+    env.with_name("max").check_layout_snapshot(&layout);
+}
+
+#[test]
+fn inbox_content_width() {
+    let mut env = testenv!();
+
+    let text = "Hello world!";
+    let mut builder = env.builder(text);
+    builder.push_inline_box(InlineBox {
+        id: 0,
+        index: 3,
+        width: 100.0,
+        height: 10.0,
+    });
+    let mut layout = builder.build(text);
+    layout.break_all_lines(Some(layout.min_content_width()));
+    layout.align(None, Alignment::Start, false);
+    env.check_layout_snapshot(&layout);
+}