Do not justify paragraph-final lines

Author: JimBobSquarePants

src/SixLabors.Fonts/TextLayout.cs

@@ -43,7 +43,7 @@ public static IReadOnlyList<TextRun> BuildTextRuns(ReadOnlySpan<char> text, Text
         int start = 0;
         int end = text.GetGraphemeCount();
         List<TextRun> textRuns = [];
-        foreach (TextRun textRun in options.TextRuns!.OrderBy(x => x.Start))
+        foreach (TextRun textRun in options.TextRuns.OrderBy(x => x.Start))
         {
             // Fill gaps within runs.
             if (textRun.Start > start)
@@ -1490,7 +1490,7 @@ VerticalOrientationType.Rotate or
                         if (textLine.TrySplitAt(breakAt, keepAll, out remaining))
                         {
                             processed = breakAt.PositionWrap;
-                            textLines.Add(textLine.Finalize());
+                            textLines.Add(textLine.Finalize(true));
                             textLine = remaining;
                         }
                     }
@@ -1529,7 +1529,7 @@ VerticalOrientationType.Rotate or
                         }
 
                         // Add the split part to the list and continue processing.
-                        textLines.Add(textLine.Finalize());
+                        textLines.Add(textLine.Finalize(breakAt.Required));
                         textLine = remaining;
                     }
                     else
@@ -1556,17 +1556,19 @@ VerticalOrientationType.Rotate or
                     }
                 }
 
-                textLines.Add(textLine.Finalize());
+                textLines.Add(textLine.Finalize(true));
                 break;
             }
         }
 
-        // Finally we justify each line except the last one
-        // The method itself determines the justification based on the options.
-        for (int i = 0; i < textLines.Count - 1; i++)
+        // Finally we justify each line that does not end a paragraph.
+        for (int i = 0; i < textLines.Count; i++)
         {
             TextLine line = textLines[i];
-            line.Justify(options);
+            if (!line.SkipJustification)
+            {
+                line.Justify(options);
+            }
         }
 
         return new TextBox(textLines);
@@ -1704,6 +1706,8 @@ internal sealed class TextLine
 
         public int Count => this.data.Count;
 
+        public bool SkipJustification { get; private set; }
+
         public float ScaledLineAdvance { get; private set; }
 
         public float ScaledMaxLineHeight { get; private set; } = -1;
@@ -1941,8 +1945,9 @@ private void TrimTrailingWhitespace()
             }
         }
 
-        public TextLine Finalize()
+        public TextLine Finalize(bool skipJustification = false)
         {
+            this.SkipJustification = skipJustification;
             this.TrimTrailingWhitespace();
             this.BidiReOrder();
             RecalculateLineMetrics(this);

tests/Images/ReferenceOutput/TextJustification_MultiParagraph_Horizontal_DoesNotJustifyParagraphFinalLines_400-_direction_LeftToRight-justification_InterCharacter_.png

@@ -694,6 +694,174 @@ public void TextJustification_InterCharacter_Horizontal(TextDirection direction)
         }
     }
 
+    [Theory]
+    [InlineData(TextDirection.LeftToRight, TextJustification.InterCharacter)]
+    [InlineData(TextDirection.LeftToRight, TextJustification.InterWord)]
+    [InlineData(TextDirection.RightToLeft, TextJustification.InterCharacter)]
+    [InlineData(TextDirection.RightToLeft, TextJustification.InterWord)]
+    public void TextJustification_MultiParagraph_Horizontal_DoesNotJustifyParagraphFinalLines(TextDirection direction, TextJustification justification)
+    {
+        const string paragraph = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc ornare maximus vehicula. Duis nisi velit, dictum id mauris vitae, lobortis pretium quam. Quisque sed nisi pulvinar, consequat justo id, feugiat leo. Cras eu elementum dui.";
+        string text = $"{paragraph}\n{paragraph}";
+        const float wrappingLength = 400;
+        const float pointSize = 12;
+        Font font = CreateRenderingFont(pointSize);
+        TextOptions options = new(font)
+        {
+            TextDirection = direction,
+            WrappingLength = wrappingLength,
+            TextJustification = justification
+        };
+
+        TextLayoutTestUtilities.TestLayout(text, options, properties: new { direction, justification });
+
+        // Compare justified and non-justified layouts line-by-line.
+        // This lets us prove that some wrapped lines are still stretched, while
+        // paragraph-final lines remain unchanged even when they are not the last
+        // line of the overall text box.
+        IReadOnlyList<IReadOnlyList<GlyphLayout>> justifiedLines = CollectLines(TextLayout.GenerateLayout(text.AsSpan(), options));
+
+        options.TextJustification = TextJustification.None;
+        IReadOnlyList<IReadOnlyList<GlyphLayout>> unJustifiedLines = CollectLines(TextLayout.GenerateLayout(text.AsSpan(), options));
+
+        Assert.Equal(unJustifiedLines.Count, justifiedLines.Count);
+
+        bool foundUnchangedNonLastLine = false;
+        bool foundJustifiedNonParagraphLine = false;
+        for (int i = 0; i < justifiedLines.Count; i++)
+        {
+            TextMeasurer.TryGetCharacterAdvances(justifiedLines[i], options.Dpi, out ReadOnlySpan<GlyphBounds> justifiedCharacterBounds);
+            TextMeasurer.TryGetCharacterAdvances(unJustifiedLines[i], options.Dpi, out ReadOnlySpan<GlyphBounds> unJustifiedCharacterBounds);
+
+            GlyphBounds[] justified = justifiedCharacterBounds.ToArray();
+            GlyphBounds[] unJustified = unJustifiedCharacterBounds.ToArray();
+
+            bool isLastLine = i == justifiedLines.Count - 1;
+            bool linesMatch = justified.Length == unJustified.Length;
+
+            // A paragraph-final line should be byte-for-byte equivalent in terms of
+            // measured per-character advances, so we first test whether every glyph
+            // advance is unchanged relative to the non-justified layout.
+            if (linesMatch)
+            {
+                for (int j = 0; j < justified.Length; j++)
+                {
+                    if (justified[j].Bounds.Width != unJustified[j].Bounds.Width)
+                    {
+                        linesMatch = false;
+                        break;
+                    }
+                }
+            }
+
+            if (isLastLine)
+            {
+                // The trailing line in the text box must never be justified.
+                Assert.True(linesMatch);
+            }
+            else
+            {
+                float justifiedWidth = justified.Sum(x => x.Bounds.Width);
+                float unJustifiedWidth = unJustified.Sum(x => x.Bounds.Width);
+
+                // At least one earlier line should stay unchanged, proving that a
+                // paragraph-final line created by the explicit newline was not justified.
+                foundUnchangedNonLastLine |= linesMatch;
+
+                // At least one other earlier line should still widen, proving that we
+                // did not disable justification for all wrapped lines.
+                foundJustifiedNonParagraphLine |= justifiedWidth > unJustifiedWidth;
+            }
+        }
+
+        // We expect both behaviors in the same layout: one unchanged paragraph-final
+        // line before the end, and one earlier wrapped line that still stretches.
+        Assert.True(foundUnchangedNonLastLine);
+        Assert.True(foundJustifiedNonParagraphLine);
+    }
+
+    [Theory]
+    [InlineData(TextDirection.LeftToRight, TextJustification.InterCharacter)]
+    [InlineData(TextDirection.LeftToRight, TextJustification.InterWord)]
+    [InlineData(TextDirection.RightToLeft, TextJustification.InterCharacter)]
+    [InlineData(TextDirection.RightToLeft, TextJustification.InterWord)]
+    public void TextJustification_MultiParagraph_Vertical_DoesNotJustifyParagraphFinalLines(TextDirection direction, TextJustification justification)
+    {
+        const string paragraph = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc ornare maximus vehicula. Duis nisi velit, dictum id mauris vitae, lobortis pretium quam. Quisque sed nisi pulvinar, consequat justo id, feugiat leo. Cras eu elementum dui.";
+        string text = $"{paragraph}\n{paragraph}";
+        const float wrappingLength = 400;
+        const float pointSize = 12;
+        Font font = CreateRenderingFont(pointSize);
+        TextOptions options = new(font)
+        {
+            LayoutMode = LayoutMode.VerticalLeftRight,
+            TextDirection = direction,
+            WrappingLength = wrappingLength,
+            TextJustification = justification
+        };
+
+        TextLayoutTestUtilities.TestLayout(text, options, properties: new { direction, justification });
+
+        // Same coverage as the horizontal test, but in vertical flow where the
+        // effective line extent is measured along height rather than width.
+        IReadOnlyList<IReadOnlyList<GlyphLayout>> justifiedLines = CollectLines(TextLayout.GenerateLayout(text.AsSpan(), options));
+
+        options.TextJustification = TextJustification.None;
+        IReadOnlyList<IReadOnlyList<GlyphLayout>> unJustifiedLines = CollectLines(TextLayout.GenerateLayout(text.AsSpan(), options));
+
+        Assert.Equal(unJustifiedLines.Count, justifiedLines.Count);
+
+        bool foundUnchangedNonLastLine = false;
+        bool foundJustifiedNonParagraphLine = false;
+        for (int i = 0; i < justifiedLines.Count; i++)
+        {
+            TextMeasurer.TryGetCharacterAdvances(justifiedLines[i], options.Dpi, out ReadOnlySpan<GlyphBounds> justifiedCharacterBounds);
+            TextMeasurer.TryGetCharacterAdvances(unJustifiedLines[i], options.Dpi, out ReadOnlySpan<GlyphBounds> unJustifiedCharacterBounds);
+
+            GlyphBounds[] justified = justifiedCharacterBounds.ToArray();
+            GlyphBounds[] unJustified = unJustifiedCharacterBounds.ToArray();
+
+            bool isLastLine = i == justifiedLines.Count - 1;
+            bool linesMatch = justified.Length == unJustified.Length;
+
+            // Paragraph-final lines should preserve every per-glyph advance from the
+            // non-justified layout, so unchanged per-character heights are the signal
+            // that a line was intentionally skipped by the justification pass.
+            if (linesMatch)
+            {
+                for (int j = 0; j < justified.Length; j++)
+                {
+                    if (justified[j].Bounds.Height != unJustified[j].Bounds.Height)
+                    {
+                        linesMatch = false;
+                        break;
+                    }
+                }
+            }
+
+            if (isLastLine)
+            {
+                // The trailing line in the text box must remain ragged in vertical layout too.
+                Assert.True(linesMatch);
+            }
+            else
+            {
+                float justifiedHeight = justified.Sum(x => x.Bounds.Height);
+                float unJustifiedHeight = unJustified.Sum(x => x.Bounds.Height);
+
+                // This captures a non-last line that still behaves like a paragraph end.
+                foundUnchangedNonLastLine |= linesMatch;
+
+                // This captures a wrapped line that continues to justify normally.
+                foundJustifiedNonParagraphLine |= justifiedHeight > unJustifiedHeight;
+            }
+        }
+
+        // Both conditions are required for the test to be meaningful.
+        Assert.True(foundUnchangedNonLastLine);
+        Assert.True(foundJustifiedNonParagraphLine);
+    }
+
     [Theory]
     [InlineData(TextDirection.LeftToRight)]
     [InlineData(TextDirection.RightToLeft)]
@@ -1569,6 +1737,27 @@ private static List<GlyphLayout> CollectFirstLine(IReadOnlyList<GlyphLayout> gly
         return line;
     }
 
+    private static IReadOnlyList<IReadOnlyList<GlyphLayout>> CollectLines(IReadOnlyList<GlyphLayout> glyphs)
+    {
+        List<IReadOnlyList<GlyphLayout>> lines = [];
+        List<GlyphLayout>? current = null;
+
+        // Re-slice the flat glyph list into visual lines using IsStartOfLine so the
+        // tests can compare whole lines instead of reasoning about glyph indices.
+        for (int i = 0; i < glyphs.Count; i++)
+        {
+            if (glyphs[i].IsStartOfLine || current is null)
+            {
+                current = [];
+                lines.Add(current);
+            }
+
+            current.Add(glyphs[i]);
+        }
+
+        return lines;
+    }
+
 #if OS_WINDOWS
     [Fact]
     public void BenchmarkTest()