Avoid measuring twice

src/rendering/line.rs

@@ -8,7 +8,7 @@ use crate::{
         line_iter::{ElementHandler, LineElementParser, LineEndType},
     },
     style::TextBoxStyle,
-    utils::{str_left_offset, str_width},
+    utils::{str_width, str_width_and_left_offset},
 };
 use embedded_graphics::{
     draw_target::DrawTarget,
@@ -105,8 +105,8 @@ where
         str_width(self.text_renderer, st)
     }
 
-    fn measure_left_offset(&self, st: &str) -> u32 {
-        str_left_offset(self.text_renderer, st)
+    fn measure_width_and_left_offset(&self, st: &str) -> (u32, u32) {
+        str_width_and_left_offset(self.text_renderer, st)
     }
 
     fn whitespace(&mut self, st: &str, _space_count: u32, width: u32) -> Result<(), Self::Error> {

src/rendering/line_iter.rs

@@ -47,7 +47,7 @@ pub trait ElementHandler {
     fn measure(&self, st: &str) -> u32;
 
     /// Returns the left offset in pixels.
-    fn measure_left_offset(&self, _st: &str) -> u32;
+    fn measure_width_and_left_offset(&self, _st: &str) -> (u32, u32);
 
     /// A whitespace block with the given width.
     fn whitespace(&mut self, _st: &str, _space_count: u32, _width: u32) -> Result<(), Self::Error> {
@@ -324,16 +324,18 @@ where
                 }
 
                 Token::Word(w) => {
-                    if self.empty {
+                    let width = if self.empty {
                         // If this is the first word on the line, offset the line by
                         // the word's left negative boundary to make sure it is not clipped.
-                        let offset = handler.measure_left_offset(w);
+                        let (width, offset) = handler.measure_width_and_left_offset(w);
                         if offset > 0 && self.move_cursor_forward(offset).is_ok() {
                             handler.whitespace("", 0, offset).ok();
                         };
-                    }
+                        width
+                    } else {
+                        handler.measure(w)
+                    };
 
-                    let width = handler.measure(w);
                     let (word, remainder) = if self.move_cursor_forward(width).is_ok() {
                         // We can move the cursor here since `process_word()`
                         // doesn't depend on it.
@@ -472,7 +474,7 @@ pub(crate) mod test {
         plugin::{NoPlugin, PluginMarker as Plugin, PluginWrapper},
         rendering::{cursor::Cursor, space_config::SpaceConfig},
         style::TabSize,
-        utils::{str_left_offset, str_width, test::size_for},
+        utils::{str_width, str_width_and_left_offset, test::size_for},
     };
     use embedded_graphics::{
         geometry::{Point, Size},
@@ -524,8 +526,8 @@ pub(crate) mod test {
             str_width(&self.style, st)
         }
 
-        fn measure_left_offset(&self, st: &str) -> u32 {
-            str_left_offset(&self.style, st)
+        fn measure_width_and_left_offset(&self, st: &str) -> (u32, u32) {
+            str_width_and_left_offset(&self.style, st)
         }
 
         fn whitespace(&mut self, _string: &str, count: u32, width: u32) -> Result<(), Self::Error> {

src/style/mod.rs

@@ -192,7 +192,7 @@ use crate::{
         line_iter::{ElementHandler, LineElementParser, LineEndType},
         space_config::SpaceConfig,
     },
-    utils::{str_left_offset, str_width},
+    utils::{str_width, str_width_and_left_offset},
 };
 use embedded_graphics::text::{renderer::TextRenderer, LineHeight};
 
@@ -385,8 +385,8 @@ impl<'a, S: TextRenderer> ElementHandler for MeasureLineElementHandler<'a, S> {
         str_width(self.style, st)
     }
 
-    fn measure_left_offset(&self, st: &str) -> u32 {
-        str_left_offset(self.style, st)
+    fn measure_width_and_left_offset(&self, st: &str) -> (u32, u32) {
+        str_width_and_left_offset(self.style, st)
     }
 
     fn whitespace(&mut self, _st: &str, count: u32, width: u32) -> Result<(), Self::Error> {

src/utils.rs

@@ -13,18 +13,17 @@ pub fn str_width(renderer: &impl TextRenderer, s: &str) -> u32 {
         .x as u32
 }
 
-/// Measure the distance between the left edge of the bounding box
-/// and the left edge of the text.
-/// This function is particularly useful when the first glyph on
+/// Measure the width of a piece of string and the offset between
+/// the left edge of the bounding box and the left edge of the text.
+///
+/// The offset is particularly useful when the first glyph on
 /// the line has a negative left side bearing.
-pub fn str_left_offset(renderer: &impl TextRenderer, s: &str) -> u32 {
-    renderer
-        .measure_string(s, Point::zero(), Baseline::Top)
-        .bounding_box
-        .top_left
-        .x
-        .min(0)
-        .abs() as u32
+pub fn str_width_and_left_offset(renderer: &impl TextRenderer, s: &str) -> (u32, u32) {
+    let tm = renderer.measure_string(s, Point::zero(), Baseline::Top);
+    (
+        tm.next_position.x as u32,
+        tm.bounding_box.top_left.x.min(0).abs() as u32,
+    )
 }
 
 #[cfg(test)]