text: truncate multi-paragraph text correctly

This commit fixes a subtle problem when trunating text widgets that contain
multiple newline-delimited paragraphs.

Paragraphs are the unit of text shaping, so we divide the text into paragraphs
and then iterate those paragraphs performing shaping and line wrapping. If we
have a maximum number of lines to fill, we stop iterating paragraphs when we
use all of the available lines. Usually, if we fill all of the lines the text
shaper will insert the truncator symbol. However, if we exactly fill all of the
lines with the end of a paragraph, the line wrapper is able to fill the line
quota without actually truncating any of the text in that paragraph. Thus it
doesn't insert a truncator even though subsequent paragraphs were truncated (it
has no way to know).

To fix this, I've taught the line wrapper about an explicit scenario in which
we always want to show the truncator symbol *if* we hit the line limit, even if
all of the text in the current paragraph fit. I've then plumbed support for
that through our text stack.

Signed-off-by: Chris Waldon <christopher.waldon.dev@gmail.com>

text/gotext.go

@@ -404,6 +404,7 @@ func (s *shaperImpl) shapeText(faces []font.Face, ppem fixed.Int26_6, lc system.
 func (s *shaperImpl) shapeAndWrapText(faces []font.Face, params Parameters, txt []rune) (_ []shaping.Line, truncated int) {
 	wc := shaping.WrapConfig{
 		TruncateAfterLines: params.MaxLines,
+		TextContinues:      params.forceTruncate,
 	}
 	if wc.TruncateAfterLines > 0 {
 		if len(params.Truncator) == 0 {
@@ -475,7 +476,9 @@ func (s *shaperImpl) LayoutRunes(params Parameters, txt []rune) document {
 	}
 	ls, truncated := s.shapeAndWrapText(s.orderer.sortedFacesForStyle(params.Font), params, replaceControlCharacters(txt))
 
-	if truncated > 0 && hasNewline {
+	didTruncate := truncated > 0 || (params.forceTruncate && params.MaxLines == len(ls))
+
+	if didTruncate && hasNewline {
 		// We've truncated the newline, since it was at the end and we've truncated some amount of runes
 		// before it.
 		truncated++
@@ -513,7 +516,7 @@ func (s *shaperImpl) LayoutRunes(params Parameters, txt []rune) document {
 				otLine.runs[finalRunIdx].Glyphs[0] = syntheticGlyph
 			}
 		}
-		if isFinalLine && truncated > 0 {
+		if isFinalLine && didTruncate {
 			// If we've truncated the text with a truncator, adjust the rune counts within the
 			// truncator to make it represent the truncated text.
 			finalRunIdx := len(otLine.runs) - 1

text/lru.go

@@ -157,6 +157,7 @@ type layoutKey struct {
 	truncator          string
 	locale             system.Locale
 	font               Font
+	forceTruncate      bool
 }
 
 type pathKey struct {

text/shaper.go

@@ -31,11 +31,17 @@ type Parameters struct {
 	// can currently ohly happen if MaxLines is nonzero and the text on the final line is
 	// truncated.
 	Truncator string
+
 	// MinWidth and MaxWidth provide the minimum and maximum horizontal space constraints
 	// for the shaped text.
 	MinWidth, MaxWidth int
 	// Locale provides primary direction and language information for the shaped text.
 	Locale system.Locale
+
+	// forceTruncate controls whether the truncator string is inserted on the final line of
+	// text with a MaxLines. It is unexported because this behavior only makes sense for the
+	// shaper to control when it iterates paragraphs of text.
+	forceTruncate bool
 }
 
 // A FontFace is a Font and a matching Face.
@@ -218,7 +224,7 @@ func (l *Shaper) reset(align Alignment) {
 // layoutText lays out a large text document by breaking it into paragraphs and laying
 // out each of them separately. This allows the shaping results to be cached independently
 // by paragraph. Only one of txt and str should be provided.
-func (l *Shaper) layoutText(params Parameters, txt io.RuneReader, str string) {
+func (l *Shaper) layoutText(params Parameters, txt *bufio.Reader, str string) {
 	l.reset(params.Alignment)
 	if txt == nil && len(str) == 0 {
 		l.txt.append(l.layoutParagraph(params, "", nil))
@@ -243,6 +249,9 @@ func (l *Shaper) layoutText(params Parameters, txt io.RuneReader, str string) {
 					break
 				}
 			}
+			_, _, re := txt.ReadRune()
+			done = re != nil
+			_ = txt.UnreadRune()
 		} else {
 			for endByte = startByte; endByte < len(str); {
 				r, width := utf8.DecodeRuneInString(str[endByte:])
@@ -255,6 +264,7 @@ func (l *Shaper) layoutText(params Parameters, txt io.RuneReader, str string) {
 			done = endByte == len(str)
 		}
 		if startByte != endByte || (len(l.paragraph) > 0 || len(l.txt.lines) == 0) {
+			params.forceTruncate = truncating && !done
 			lines := l.layoutParagraph(params, str[startByte:endByte], l.paragraph)
 			if truncating {
 				params.MaxLines -= len(lines.lines)
@@ -290,6 +300,9 @@ func (l *Shaper) layoutText(params Parameters, txt io.RuneReader, str string) {
 	}
 }
 
+// layoutParagraph shapes and wraps a paragraph using the provided parameters.
+// It accepts the paragraph data in either string or rune format, preferring the
+// string in order to hit the shaper cache more quickly.
 func (l *Shaper) layoutParagraph(params Parameters, asStr string, asRunes []rune) document {
 	if l == nil {
 		return document{}
@@ -299,14 +312,15 @@ func (l *Shaper) layoutParagraph(params Parameters, asStr string, asRunes []rune
 	}
 	// Alignment is not part of the cache key because changing it does not impact shaping.
 	lk := layoutKey{
-		ppem:      params.PxPerEm,
-		maxWidth:  params.MaxWidth,
-		minWidth:  params.MinWidth,
-		maxLines:  params.MaxLines,
-		truncator: params.Truncator,
-		locale:    params.Locale,
-		font:      params.Font,
-		str:       asStr,
+		ppem:          params.PxPerEm,
+		maxWidth:      params.MaxWidth,
+		minWidth:      params.MinWidth,
+		maxLines:      params.MaxLines,
+		truncator:     params.Truncator,
+		locale:        params.Locale,
+		font:          params.Font,
+		forceTruncate: params.forceTruncate,
+		str:           asStr,
 	}
 	if l, ok := l.layoutCache.Get(lk); ok {
 		return l

text/shaper_test.go

@@ -80,6 +80,74 @@ func TestWrappingTruncation(t *testing.T) {
 	}
 }
 
+// TestWrappingForcedTruncation checks that the line wrapper's truncation features
+// activate correctly on multi-paragraph text when later paragraphs are truncated.
+func TestWrappingForcedTruncation(t *testing.T) {
+	// Use a test string containing multiple newlines to ensure that they are shaped
+	// as separate paragraphs.
+	textInput := "Lorem ipsum\ndolor sit\namet"
+	ltrFace, _ := opentype.Parse(goregular.TTF)
+	collection := []FontFace{{Face: ltrFace}}
+	cache := NewShaper(collection)
+	cache.LayoutString(Parameters{
+		Alignment: Middle,
+		PxPerEm:   fixed.I(10),
+		MinWidth:  200,
+		MaxWidth:  200,
+		Locale:    english,
+	}, textInput)
+	untruncatedCount := len(cache.txt.lines)
+
+	for i := untruncatedCount + 1; i > 0; i-- {
+		t.Run(fmt.Sprintf("truncated to %d/%d lines", i, untruncatedCount), func(t *testing.T) {
+			cache.LayoutString(Parameters{
+				Alignment: Middle,
+				PxPerEm:   fixed.I(10),
+				MaxLines:  i,
+				MinWidth:  200,
+				MaxWidth:  200,
+				Locale:    english,
+			}, textInput)
+			lineCount := 0
+			glyphs := []Glyph{}
+			untruncatedRunes := 0
+			truncatedRunes := 0
+			for g, ok := cache.NextGlyph(); ok; g, ok = cache.NextGlyph() {
+				glyphs = append(glyphs, g)
+				if g.Flags&FlagTruncator != 0 && g.Flags&FlagClusterBreak != 0 {
+					truncatedRunes += g.Runes
+				} else {
+					untruncatedRunes += g.Runes
+				}
+				if g.Flags&FlagLineBreak != 0 {
+					lineCount++
+				}
+			}
+			expectedTruncated := false
+			expectedLines := 0
+			if i < untruncatedCount {
+				expectedLines = i
+				expectedTruncated = true
+			} else if i == untruncatedCount {
+				expectedLines = i
+				expectedTruncated = false
+			} else if i > untruncatedCount {
+				expectedLines = untruncatedCount
+				expectedTruncated = false
+			}
+			if lineCount != expectedLines {
+				t.Errorf("expected %d lines, got %d", expectedLines, lineCount)
+			}
+			if truncatedRunes > 0 != expectedTruncated {
+				t.Errorf("expected expectedTruncated=%v, truncatedRunes=%d", expectedTruncated, truncatedRunes)
+			}
+			if expected := len([]rune(textInput)); truncatedRunes+untruncatedRunes != expected {
+				t.Errorf("expected %d total runes, got %d (%d truncated)", expected, truncatedRunes+untruncatedRunes, truncatedRunes)
+			}
+		})
+	}
+}
+
 // TestShapingNewlineHandling checks that the shaper's newline splitting behaves
 // consistently and does not create spurious lines of text.
 func TestShapingNewlineHandling(t *testing.T) {