Use Layout::width instead of calculating for alignment (#269)

This does require line breaking to have happened, but that is already a
requirement, as otherwise `Layout::lines` is empty.

This is a slight change in behavior, as trailing white space is no
longer included in the alignment width.

Author: tomcur

parley/src/layout/alignment.rs

@@ -15,28 +15,26 @@ pub(crate) fn align<B: Brush>(
 ) {
     // Whether the text base direction is right-to-left.
     let is_rtl = layout.base_level & 1 == 1;
-    let alignment_width = alignment_width.unwrap_or_else(|| {
-        let max_line_length = layout
-            .lines
-            .iter()
-            .map(|line| line.metrics.advance)
-            .max_by(f32::total_cmp)
-            .unwrap_or(0.0);
-        max_line_length.min(max_line_length)
-    });
+    let alignment_width = alignment_width.unwrap_or(layout.width);
 
     // Apply alignment to line items
     for line in &mut layout.lines {
         // TODO: remove this field
         line.alignment = alignment;
 
+        if is_rtl {
+            // In RTL text, trailing whitespace is on the left. As we hang that whitespace, offset
+            // the line to the left.
+            line.metrics.offset = -line.metrics.trailing_whitespace;
+        }
+
         // Compute free space.
         let free_space = alignment_width - line.metrics.advance + line.metrics.trailing_whitespace;
 
         if !align_when_overflowing && free_space <= 0.0 {
             if is_rtl {
                 // In RTL text, right-align on overflow.
-                line.metrics.offset = free_space;
+                line.metrics.offset += free_space;
             }
             continue;
         }
@@ -46,10 +44,10 @@ pub(crate) fn align<B: Brush>(
                 // Do nothing
             }
             (Alignment::Right, _) | (Alignment::Start, true) | (Alignment::End, false) => {
-                line.metrics.offset = free_space;
+                line.metrics.offset += free_space;
             }
             (Alignment::Middle, _) => {
-                line.metrics.offset = free_space * 0.5;
+                line.metrics.offset += free_space * 0.5;
             }
             (Alignment::Justified, _) => {
                 // Justified alignment doesn't have any effect if free_space is negative or zero
@@ -62,7 +60,7 @@ pub(crate) fn align<B: Brush>(
                 // case, start-align, i.e., left-align for LTR text and right-align for RTL text.
                 if line.break_reason == BreakReason::None || line.num_spaces == 0 {
                     if is_rtl {
-                        line.metrics.offset = free_space;
+                        line.metrics.offset += free_space;
                     }
                     continue;
                 }
@@ -100,12 +98,6 @@ pub(crate) fn align<B: Brush>(
                     });
             }
         }
-
-        if is_rtl {
-            // In RTL text, trailing whitespace is on the left. As we hang that whitespace, offset
-            // the line to the left.
-            line.metrics.offset -= line.metrics.trailing_whitespace;
-        }
     }
 }
 

parley/src/layout/mod.rs

@@ -156,12 +156,16 @@ impl<B: Brush> Layout<B> {
             .break_remaining(max_advance.unwrap_or(f32::MAX));
     }
 
-    // Apply to alignment to layout relative to the specified container width. If container_width is not
-    // specified then the max line length is used.
-    //
-    // If `align_when_overflowing` is set to `true` then `Center` and `End` alignment will apply even if
-    // the line contents are wider than the `container_width`. If it is set to `false` then all overflowing
-    // lines will be `Start` aligned.
+    /// Apply alignment to the layout relative to the specified container width or full layout
+    /// width.
+    ///
+    /// You must perform line breaking prior to aligning, through [`Layout::break_lines`] or
+    /// [`Layout::break_all_lines`]. If `container_width` is not specified, the layout's
+    /// [`Layout::width`] is used.
+    ///
+    /// If `align_when_overflowing` is set to `true`, alignment will apply even if the line
+    /// contents are wider than the alignment width. If it is set to `false`, all overflowing lines
+    /// will be [`Alignment::Start`] aligned.
     pub fn align(
         &mut self,
         container_width: Option<f32>,