| // Copyright 2014 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import 'dart:ui' as ui; |
| |
| import 'package:flutter/foundation.dart'; |
| import 'package:flutter/widgets.dart'; |
| import 'package:flutter_test/flutter_test.dart'; |
| import 'package:leak_tracker_flutter_testing/leak_tracker_flutter_testing.dart'; |
| |
| void _checkCaretOffsetsLtrAt(String text, List<int> boundaries) { |
| expect(boundaries.first, 0); |
| expect(boundaries.last, text.length); |
| |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| // Lay out the string up to each boundary, and record the width. |
| final prefixWidths = <double>[]; |
| for (final boundary in boundaries) { |
| painter.text = TextSpan(text: text.substring(0, boundary)); |
| painter.layout(); |
| prefixWidths.add(painter.width); |
| } |
| |
| // The painter has the full text laid out. Check the caret offsets. |
| double caretOffset(int offset) { |
| final position = ui.TextPosition(offset: offset); |
| return painter.getOffsetForCaret(position, ui.Rect.zero).dx; |
| } |
| |
| expect(boundaries.map(caretOffset).toList(), prefixWidths); |
| double lastOffset = caretOffset(0); |
| for (var i = 1; i <= text.length; i++) { |
| final double offset = caretOffset(i); |
| expect(offset, greaterThanOrEqualTo(lastOffset)); |
| lastOffset = offset; |
| } |
| painter.dispose(); |
| } |
| |
| /// Check the caret offsets are accurate for the given single line of LTR text. |
| /// |
| /// This lays out the given text as a single line with [TextDirection.ltr] |
| /// and checks the following invariants, which should always hold if the text |
| /// is made up of LTR characters: |
| /// * The caret offsets go monotonically from 0.0 to the width of the text. |
| /// * At each character (that is, grapheme cluster) boundary, the caret |
| /// offset equals the width that the text up to that point would have |
| /// if laid out on its own. |
| /// |
| /// If you have a [TextSpan] instead of a plain [String], |
| /// see [caretOffsetsForTextSpan]. |
| void checkCaretOffsetsLtr(String text) { |
| final characterBoundaries = <int>[]; |
| final range = CharacterRange.at(text, 0); |
| while (true) { |
| characterBoundaries.add(range.current.length); |
| if (range.stringAfterLength <= 0) { |
| break; |
| } |
| range.expandNext(); |
| } |
| _checkCaretOffsetsLtrAt(text, characterBoundaries); |
| } |
| |
| /// Check the caret offsets are accurate for the given single line of LTR text, |
| /// ignoring character boundaries within each given cluster. |
| /// |
| /// This concatenates [clusters] into a string and then performs the same |
| /// checks as [checkCaretOffsetsLtr], except that instead of checking the |
| /// offset-equals-prefix-width invariant at every character boundary, |
| /// it does so only at the boundaries between the elements of [clusters]. |
| /// |
| /// The elements of [clusters] should be composed of whole characters: each |
| /// element should be a valid character range in the concatenated string. |
| /// |
| /// Consider using [checkCaretOffsetsLtr] instead of this function. If that |
| /// doesn't pass, you may have an instance of <https://github.com/flutter/flutter/issues/122478>. |
| void checkCaretOffsetsLtrFromPieces(List<String> clusters) { |
| final buffer = StringBuffer(); |
| final boundaries = <int>[]; |
| boundaries.add(buffer.length); |
| for (final cluster in clusters) { |
| buffer.write(cluster); |
| boundaries.add(buffer.length); |
| } |
| _checkCaretOffsetsLtrAt(buffer.toString(), boundaries); |
| } |
| |
| /// Compute the caret offsets for the given single line of text, a [TextSpan]. |
| /// |
| /// This lays out the given text as a single line with the given [textDirection] |
| /// and returns a full list of caret offsets, one at each code unit boundary. |
| /// |
| /// This also checks that the offset at the very start or very end, if the text |
| /// direction is RTL or LTR respectively, equals the line's width. |
| /// |
| /// If you have a [String] instead of a nontrivial [TextSpan], |
| /// consider using [checkCaretOffsetsLtr] instead. |
| List<double> caretOffsetsForTextSpan(TextDirection textDirection, TextSpan text) { |
| final painter = TextPainter() |
| ..textDirection = textDirection |
| ..text = text |
| ..layout(); |
| final int length = text.toPlainText().length; |
| final result = List<double>.generate(length + 1, (int offset) { |
| final position = ui.TextPosition(offset: offset); |
| return painter.getOffsetForCaret(position, ui.Rect.zero).dx; |
| }); |
| switch (textDirection) { |
| case TextDirection.ltr: |
| expect(result[length], painter.width); |
| case TextDirection.rtl: |
| expect(result[0], painter.width); |
| } |
| painter.dispose(); |
| return result; |
| } |
| |
| void main() { |
| group('caret', () { |
| test('TextPainter caret test', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| var text = 'A'; |
| checkCaretOffsetsLtr(text); |
| |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| |
| Offset caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: 0), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0); |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: text.length), ui.Rect.zero); |
| expect(caretOffset.dx, painter.width); |
| |
| // Check that getOffsetForCaret handles a character that is encoded as a |
| // surrogate pair. |
| text = 'A\u{1F600}'; |
| checkCaretOffsetsLtr(text); |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: text.length), ui.Rect.zero); |
| expect(caretOffset.dx, painter.width); |
| |
| /// Verify the handling of spaces by SkParagraph and TextPainter. |
| /// |
| /// Test characters that are in the Unicode-Zs category but are not treated as whitespace characters by SkParagraph. |
| /// The following character codes are intentionally excluded from the test target. |
| /// * '\u{00A0}' (no-break space) |
| /// * '\u{2007}' (figure space) |
| /// * '\u{202F}' (narrow no-break space) |
| void verifyCharacterIsConsideredTrailingSpace(String character) { |
| final reason = 'character: ${character.codeUnitAt(0).toRadixString(16)}'; |
| |
| text = 'A$character'; |
| checkCaretOffsetsLtr(text); |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 0), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0, reason: reason); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 1), ui.Rect.zero); |
| expect(caretOffset.dx, 14.0, reason: reason); |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: text.length), ui.Rect.zero); |
| expect(caretOffset.dx, painter.width, reason: reason); |
| |
| painter.layout(maxWidth: 14.0); |
| final List<ui.LineMetrics> lines = painter.computeLineMetrics(); |
| expect(lines.length, 1, reason: reason); |
| expect(lines.first.width, 14.0, reason: reason); |
| } |
| |
| // Test with trailing space. |
| verifyCharacterIsConsideredTrailingSpace('\u{0020}'); |
| |
| // Test with trailing full-width space. |
| verifyCharacterIsConsideredTrailingSpace('\u{3000}'); |
| |
| // Test with trailing ogham space mark. |
| verifyCharacterIsConsideredTrailingSpace('\u{1680}'); |
| |
| // Test with trailing en quad. |
| verifyCharacterIsConsideredTrailingSpace('\u{2000}'); |
| |
| // Test with trailing em quad. |
| verifyCharacterIsConsideredTrailingSpace('\u{2001}'); |
| |
| // Test with trailing en space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2002}'); |
| |
| // Test with trailing em space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2003}'); |
| |
| // Test with trailing three-per-em space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2004}'); |
| |
| // Test with trailing four-per-em space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2005}'); |
| |
| // Test with trailing six-per-em space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2006}'); |
| |
| // Test with trailing punctuation space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2008}'); |
| |
| // Test with trailing thin space. |
| verifyCharacterIsConsideredTrailingSpace('\u{2009}'); |
| |
| // Test with trailing hair space. |
| verifyCharacterIsConsideredTrailingSpace('\u{200A}'); |
| |
| // Test with trailing medium mathematical space(MMSP). |
| verifyCharacterIsConsideredTrailingSpace('\u{205F}'); |
| |
| painter.dispose(); |
| }); |
| |
| test('TextPainter caret test with WidgetSpan', () { |
| // Regression test for https://github.com/flutter/flutter/issues/98458. |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| painter.text = const TextSpan( |
| children: <InlineSpan>[ |
| TextSpan(text: 'before'), |
| WidgetSpan(child: Text('widget')), |
| TextSpan(text: 'after'), |
| ], |
| ); |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| ]); |
| painter.layout(); |
| final Offset caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: painter.text!.toPlainText().length), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, painter.width); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter null text test', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| var children = <TextSpan>[const TextSpan(text: 'B'), const TextSpan(text: 'C')]; |
| painter.text = TextSpan(children: children); |
| painter.layout(); |
| |
| Offset caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: 0), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 1), ui.Rect.zero); |
| expect(caretOffset.dx, painter.width / 2); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 2), ui.Rect.zero); |
| expect(caretOffset.dx, painter.width); |
| |
| children = <TextSpan>[]; |
| painter.text = TextSpan(children: children); |
| painter.layout(); |
| |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 0), ui.Rect.zero); |
| expect(caretOffset.dx, 0); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 1), ui.Rect.zero); |
| expect(caretOffset.dx, 0); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter caret emoji test', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| // Format: '👩<zwj>👩<zwj>👦👩<zwj>👩<zwj>👧<zwj>👧👏<modifier>' |
| // One three-person family, one four-person family, one clapping hands (medium skin tone). |
| const text = '👩👩👦👩👩👧👧👏🏽'; |
| checkCaretOffsetsLtr(text); |
| |
| painter.text = const TextSpan(text: text); |
| painter.layout(maxWidth: 10000); |
| |
| expect(text.length, 23); |
| |
| Offset caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: 0), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0); // 👩 |
| caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: text.length), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, painter.width); |
| |
| // Two UTF-16 codepoints per emoji, one codepoint per zwj |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 1), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 2), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // <zwj> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 3), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 4), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 5), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // <zwj> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 6), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // 👦 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 7), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // 👦 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 8), ui.Rect.zero); |
| expect(caretOffset.dx, 42); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 9), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 10), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // <zwj> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 11), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 12), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👩 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 13), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // <zwj> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 14), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👧 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 15), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👧 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 16), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // <zwj> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 17), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👧 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 18), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👧 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 19), ui.Rect.zero); |
| expect(caretOffset.dx, 98); // 👏 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 20), ui.Rect.zero); |
| expect(caretOffset.dx, 126); // 👏 |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 21), ui.Rect.zero); |
| expect(caretOffset.dx, 126); // <medium skin tone modifier> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 22), ui.Rect.zero); |
| expect(caretOffset.dx, 126); // <medium skin tone modifier> |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 23), ui.Rect.zero); |
| expect(caretOffset.dx, 126); // end of string |
| painter.dispose(); |
| }); |
| |
| test('TextPainter caret emoji tests: single, long emoji', () { |
| // Regression test for https://github.com/flutter/flutter/issues/50563 |
| checkCaretOffsetsLtr('👩🚀'); |
| checkCaretOffsetsLtr('👩❤️💋👩'); |
| checkCaretOffsetsLtr('👨👩👦👦'); |
| checkCaretOffsetsLtr('👨🏾🤝👨🏻'); |
| checkCaretOffsetsLtr('👨👦'); |
| checkCaretOffsetsLtr('👩👦'); |
| checkCaretOffsetsLtr('🏌🏿♀️'); |
| checkCaretOffsetsLtr('🏊♀️'); |
| checkCaretOffsetsLtr('🏄🏻♂️'); |
| |
| // These actually worked even before #50563 was fixed (because |
| // their lengths in code units are powers of 2, namely 4 and 8). |
| checkCaretOffsetsLtr('🇺🇳'); |
| checkCaretOffsetsLtr('👩❤️👨'); |
| }); |
| |
| test('TextPainter caret emoji test: letters, then 1 emoji of 5 code units', () { |
| // Regression test for https://github.com/flutter/flutter/issues/50563 |
| checkCaretOffsetsLtr('a👩🚀'); |
| checkCaretOffsetsLtr('ab👩🚀'); |
| checkCaretOffsetsLtr('abc👩🚀'); |
| checkCaretOffsetsLtr('abcd👩🚀'); |
| }); |
| |
| test('TextPainter caret zalgo test', () { |
| // Regression test for https://github.com/flutter/flutter/issues/98516 |
| checkCaretOffsetsLtr('Z͉̳̺ͥͬ̾a̴͕̲̒̒͌̋ͪl̨͎̰̘͉̟ͤ̀̈̚͜g͕͔̤͖̟̒͝ͅo̵̡̡̼͚̐ͯ̅ͪ̆ͣ̚'); |
| }); |
| |
| test('TextPainter caret Devanagari test', () { |
| // Regression test for https://github.com/flutter/flutter/issues/118403 |
| checkCaretOffsetsLtrFromPieces(<String>[ |
| 'प्रा', |
| 'प्त', |
| ' ', |
| 'व', |
| 'र्ण', |
| 'न', |
| ' ', |
| 'प्र', |
| 'व्रु', |
| 'ति', |
| ]); |
| }); |
| |
| test('TextPainter caret Devanagari test, full strength', () { |
| // Regression test for https://github.com/flutter/flutter/issues/118403 |
| checkCaretOffsetsLtr('प्राप्त वर्णन प्रव्रुति'); |
| }, skip: true); // https://github.com/flutter/flutter/issues/122478 |
| |
| test('TextPainter caret emoji test LTR: letters next to emoji, as separate TextBoxes', () { |
| // Regression test for https://github.com/flutter/flutter/issues/122477 |
| // The trigger for this bug was to have SkParagraph report separate |
| // TextBoxes for the emoji and for the characters next to it. |
| // In normal usage on a real device, this can happen by simply typing |
| // letters and then an emoji, presumably because they get different fonts. |
| // In these tests, our single test font covers both letters and emoji, |
| // so we provoke the same effect by adding styles. |
| expect( |
| caretOffsetsForTextSpan( |
| TextDirection.ltr, |
| const TextSpan( |
| children: <TextSpan>[ |
| TextSpan(text: '👩🚀', style: TextStyle()), |
| TextSpan( |
| text: ' words', |
| style: TextStyle(fontWeight: FontWeight.bold), |
| ), |
| ], |
| ), |
| ), |
| <double>[0, 28, 28, 28, 28, 28, 42, 56, 70, 84, 98, 112], |
| ); |
| expect( |
| caretOffsetsForTextSpan( |
| TextDirection.ltr, |
| const TextSpan( |
| children: <TextSpan>[ |
| TextSpan( |
| text: 'words ', |
| style: TextStyle(fontWeight: FontWeight.bold), |
| ), |
| TextSpan(text: '👩🚀', style: TextStyle()), |
| ], |
| ), |
| ), |
| <double>[0, 14, 28, 42, 56, 70, 84, 112, 112, 112, 112, 112], |
| ); |
| }); |
| |
| test('TextPainter caret emoji test RTL: letters next to emoji, as separate TextBoxes', () { |
| // Regression test for https://github.com/flutter/flutter/issues/122477 |
| expect( |
| caretOffsetsForTextSpan( |
| TextDirection.rtl, |
| const TextSpan( |
| children: <TextSpan>[ |
| TextSpan(text: '👩🚀', style: TextStyle()), |
| TextSpan( |
| text: ' מילים', |
| style: TextStyle(fontWeight: FontWeight.bold), |
| ), |
| ], |
| ), |
| ), |
| <double>[112, 84, 84, 84, 84, 84, 70, 56, 42, 28, 14, 0], |
| ); |
| expect( |
| caretOffsetsForTextSpan( |
| TextDirection.rtl, |
| const TextSpan( |
| children: <TextSpan>[ |
| TextSpan( |
| text: 'מילים ', |
| style: TextStyle(fontWeight: FontWeight.bold), |
| ), |
| TextSpan(text: '👩🚀', style: TextStyle()), |
| ], |
| ), |
| ), |
| <double>[112, 98, 84, 70, 56, 42, 28, 0, 0, 0, 0, 0], |
| ); |
| }); |
| |
| test('TextPainter caret center space test', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| const text = 'test text with space at end '; |
| painter.text = const TextSpan(text: text); |
| painter.textAlign = TextAlign.center; |
| painter.layout(); |
| |
| Offset caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: 0), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 21); |
| caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: text.length), |
| ui.Rect.zero, |
| ); |
| // The end of the line is 441, but the width is only 420, so the cursor is |
| // stopped there without overflowing. |
| expect(caretOffset.dx, painter.width); |
| |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 1), ui.Rect.zero); |
| expect(caretOffset.dx, 35); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 2), ui.Rect.zero); |
| expect(caretOffset.dx, 49); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter caret height and line height', () { |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..strutStyle = const StrutStyle(fontSize: 50.0); |
| |
| const text = 'A'; |
| painter.text = const TextSpan(text: text, style: TextStyle(height: 1.0)); |
| painter.layout(); |
| |
| final double caretHeight = painter.getFullHeightForCaret( |
| const ui.TextPosition(offset: 0), |
| ui.Rect.zero, |
| ); |
| expect(caretHeight, 50.0); |
| painter.dispose(); |
| }); |
| |
| test('upstream downstream makes no difference in the same line within the same bidi run', () { |
| final painter = TextPainter(textDirection: TextDirection.ltr) |
| ..text = const TextSpan(text: 'aa') |
| ..layout(); |
| |
| final Rect largeRect = Offset.zero & const Size.square(5); |
| expect( |
| painter.getOffsetForCaret(const TextPosition(offset: 1), largeRect), |
| painter.getOffsetForCaret( |
| const TextPosition(offset: 1, affinity: TextAffinity.upstream), |
| largeRect, |
| ), |
| ); |
| }); |
| |
| test('trailing newlines', () { |
| const fontSize = 14.0; |
| final painter = TextPainter(); |
| final Rect largeRect = Offset.zero & const Size.square(5); |
| var text = 'a '; |
| painter |
| ..text = TextSpan(text: text) |
| ..textDirection = TextDirection.ltr |
| ..layout(minWidth: 1000.0, maxWidth: 1000.0); |
| expect( |
| painter.getOffsetForCaret(TextPosition(offset: text.length), largeRect).dx, |
| text.length * fontSize, |
| ); |
| |
| text = 'ل '; |
| painter |
| ..text = TextSpan(text: text) |
| ..textDirection = TextDirection.rtl |
| ..layout(minWidth: 1000.0, maxWidth: 1000.0); |
| expect( |
| painter.getOffsetForCaret(TextPosition(offset: text.length), largeRect).dx, |
| 1000 - text.length * fontSize - largeRect.width, |
| ); |
| }); |
| |
| test('End of text caret when the text ends with +1 bidi level', () { |
| const fontSize = 14.0; |
| final painter = TextPainter(); |
| final Rect largeRect = Offset.zero & const Size.square(5); |
| const text = 'aل'; |
| painter |
| ..text = const TextSpan(text: text) |
| ..textDirection = TextDirection.ltr |
| ..layout(minWidth: 1000.0, maxWidth: 1000.0); |
| |
| expect(painter.getOffsetForCaret(const TextPosition(offset: 0), largeRect).dx, 0.0); |
| expect( |
| painter.getOffsetForCaret(const TextPosition(offset: 1), largeRect).dx, |
| fontSize * 2 - largeRect.width, |
| ); |
| expect(painter.getOffsetForCaret(const TextPosition(offset: 2), largeRect).dx, fontSize * 2); |
| }); |
| |
| test('handles newlines properly', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| const SIZE_OF_A = 14.0; // square size of "a" character |
| var text = 'aaa'; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| |
| // getOffsetForCaret in a plain one-line string is the same for either affinity. |
| var offset = 0; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| Offset caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| offset = 1; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| offset = 2; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| offset = 3; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, SIZE_OF_A * offset); |
| expect(caretOffset.dy, 0.0); |
| |
| // For explicit newlines, getOffsetForCaret places the caret at the location |
| // indicated by offset regardless of affinity. |
| text = '\n\n'; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| offset = 0; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| offset = 1; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| offset = 2; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 2); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 2); |
| |
| // getOffsetForCaret in an unwrapped string with explicit newlines is the |
| // same for either affinity. |
| text = '\naaa'; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| offset = 0; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| offset = 1; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| |
| // When text wraps on its own, getOffsetForCaret disambiguates between the |
| // end of one line and start of next using affinity. |
| text = 'aaaaaaaa'; // Just enough to wrap one character down to second line |
| painter.text = TextSpan(text: text); |
| painter.layout(maxWidth: 100); // SIZE_OF_A * text.length > 100, so it wraps |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: text.length - 1), |
| ui.Rect.zero, |
| ); |
| // When affinity is downstream, cursor is at beginning of second line |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: text.length - 1, affinity: ui.TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| // When affinity is upstream, cursor is at end of first line |
| expect(caretOffset.dx, 98.0); |
| expect(caretOffset.dy, 0.0); |
| |
| // When given a string with a newline at the end, getOffsetForCaret puts |
| // the cursor at the start of the next line regardless of affinity |
| text = 'aaa\n'; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: text.length), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| offset = text.length; |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| |
| // Given a one-line right aligned string, positioning the cursor at offset 0 |
| // means that it appears at the "end" of the string, after the character |
| // that was typed first, at x=0. |
| painter.textAlign = TextAlign.right; |
| text = 'aaa'; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| offset = 0; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| painter.textAlign = TextAlign.left; |
| |
| // When given an offset after a newline in the middle of a string, |
| // getOffsetForCaret returns the start of the next line regardless of |
| // affinity. |
| text = 'aaa\naaa'; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| offset = 4; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| |
| // When given a string with multiple trailing newlines, places the caret |
| // in the position given by offset regardless of affinity. |
| text = 'aaa\n\n\n'; |
| offset = 3; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, SIZE_OF_A * 3); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, SIZE_OF_A * 3); |
| expect(caretOffset.dy, 0.0); |
| |
| offset = 4; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| |
| offset = 5; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 2); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 2); |
| |
| offset = 6; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 3); |
| |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 3); |
| |
| // When given a string with multiple leading newlines, places the caret in |
| // the position given by offset regardless of affinity. |
| text = '\n\n\naaa'; |
| offset = 3; |
| painter.text = TextSpan(text: text); |
| painter.layout(); |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 3); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 3); |
| |
| offset = 2; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 2); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A * 2); |
| |
| offset = 1; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, SIZE_OF_A); |
| |
| offset = 0; |
| caretOffset = painter.getOffsetForCaret(ui.TextPosition(offset: offset), ui.Rect.zero); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| caretOffset = painter.getOffsetForCaret( |
| ui.TextPosition(offset: offset, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, 0.0); |
| expect(caretOffset.dy, 0.0); |
| painter.dispose(); |
| }); |
| |
| test('caret height reflects run height if strut is disabled', () { |
| const span = TextSpan( |
| text: 'M', |
| style: TextStyle(fontSize: 128), |
| children: <InlineSpan>[ |
| TextSpan(text: 'M', style: TextStyle(fontSize: 32)), |
| TextSpan(text: 'M', style: TextStyle(fontSize: 64)), |
| ], |
| ); |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = span |
| ..layout(); |
| |
| expect( |
| painter.getFullHeightForCaret( |
| const TextPosition(offset: 0, affinity: ui.TextAffinity.upstream), |
| Rect.zero, |
| ), |
| 128.0, |
| ); |
| expect(painter.getFullHeightForCaret(const TextPosition(offset: 0), Rect.zero), 128.0); |
| expect( |
| painter.getFullHeightForCaret( |
| const TextPosition(offset: 1, affinity: ui.TextAffinity.upstream), |
| Rect.zero, |
| ), |
| 128.0, |
| ); |
| expect(painter.getFullHeightForCaret(const TextPosition(offset: 1), Rect.zero), 32.0); |
| expect( |
| painter.getFullHeightForCaret( |
| const TextPosition(offset: 2, affinity: ui.TextAffinity.upstream), |
| Rect.zero, |
| ), |
| 32.0, |
| ); |
| expect(painter.getFullHeightForCaret(const TextPosition(offset: 2), Rect.zero), 64.0); |
| expect( |
| painter.getFullHeightForCaret( |
| const TextPosition(offset: 3, affinity: ui.TextAffinity.upstream), |
| Rect.zero, |
| ), |
| 64.0, |
| ); |
| expect(painter.getFullHeightForCaret(const TextPosition(offset: 3), Rect.zero), 128.0); |
| |
| painter.dispose(); |
| }); |
| }); |
| |
| test('TextPainter error test', () { |
| final painter = TextPainter(textDirection: TextDirection.ltr); |
| |
| expect( |
| () => painter.paint(MockCanvas(), Offset.zero), |
| throwsA( |
| isA<StateError>().having( |
| (StateError error) => error.message, |
| 'message', |
| contains('TextPainter.paint called when text geometry was not yet calculated'), |
| ), |
| ), |
| ); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter requires textDirection', () { |
| final painter1 = TextPainter(text: const TextSpan(text: '')); |
| expect(painter1.layout, throwsStateError); |
| final painter2 = TextPainter( |
| text: const TextSpan(text: ''), |
| textDirection: TextDirection.rtl, |
| ); |
| expect(painter2.layout, isNot(throwsStateError)); |
| }); |
| |
| test('TextPainter size test', () { |
| final painter = TextPainter( |
| text: const TextSpan(text: 'X', style: TextStyle(inherit: false, fontSize: 123.0)), |
| textDirection: TextDirection.ltr, |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(123.0, 123.0)); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter textScaler test', () { |
| final painter = TextPainter( |
| text: const TextSpan(text: 'X', style: TextStyle(inherit: false, fontSize: 10.0)), |
| textDirection: TextDirection.ltr, |
| textScaler: const TextScaler.linear(2.0), |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(20.0, 20.0)); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter textScaler null style test', () { |
| final painter = TextPainter( |
| text: const TextSpan(text: 'X'), |
| textDirection: TextDirection.ltr, |
| textScaler: const TextScaler.linear(2.0), |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(28.0, 28.0)); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter default text height is 14 pixels', () { |
| final painter = TextPainter( |
| text: const TextSpan(text: 'x'), |
| textDirection: TextDirection.ltr, |
| ); |
| painter.layout(); |
| expect(painter.preferredLineHeight, 14.0); |
| expect(painter.size, const Size(14.0, 14.0)); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter sets paragraph size from root', () { |
| final painter = TextPainter( |
| text: const TextSpan(text: 'x', style: TextStyle(fontSize: 100.0)), |
| textDirection: TextDirection.ltr, |
| ); |
| painter.layout(); |
| expect(painter.preferredLineHeight, 100.0); |
| expect(painter.size, const Size(100.0, 100.0)); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter intrinsic dimensions', () { |
| const style = TextStyle(inherit: false, fontSize: 10.0); |
| TextPainter painter; |
| |
| painter = TextPainter( |
| text: const TextSpan(text: 'X X X', style: style), |
| textDirection: TextDirection.ltr, |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(50.0, 10.0)); |
| expect(painter.minIntrinsicWidth, 10.0); |
| expect(painter.maxIntrinsicWidth, 50.0); |
| painter.dispose(); |
| |
| painter = TextPainter( |
| text: const TextSpan(text: 'X X X', style: style), |
| textDirection: TextDirection.ltr, |
| ellipsis: 'e', |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(50.0, 10.0)); |
| expect(painter.minIntrinsicWidth, 50.0); |
| expect(painter.maxIntrinsicWidth, 50.0); |
| painter.dispose(); |
| |
| painter = TextPainter( |
| text: const TextSpan(text: 'X X XXXX', style: style), |
| textDirection: TextDirection.ltr, |
| maxLines: 2, |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(80.0, 10.0)); |
| expect(painter.minIntrinsicWidth, 40.0); |
| expect(painter.maxIntrinsicWidth, 80.0); |
| painter.dispose(); |
| |
| painter = TextPainter( |
| text: const TextSpan(text: 'X X XXXX XX', style: style), |
| textDirection: TextDirection.ltr, |
| maxLines: 2, |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(110.0, 10.0)); |
| expect(painter.minIntrinsicWidth, 70.0); |
| expect(painter.maxIntrinsicWidth, 110.0); |
| painter.dispose(); |
| |
| painter = TextPainter( |
| text: const TextSpan(text: 'XXXXXXXX XXXX XX X', style: style), |
| textDirection: TextDirection.ltr, |
| maxLines: 2, |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(180.0, 10.0)); |
| expect(painter.minIntrinsicWidth, 90.0); |
| expect(painter.maxIntrinsicWidth, 180.0); |
| painter.dispose(); |
| |
| painter = TextPainter( |
| text: const TextSpan(text: 'X XX XXXX XXXXXXXX', style: style), |
| textDirection: TextDirection.ltr, |
| maxLines: 2, |
| ); |
| painter.layout(); |
| expect(painter.size, const Size(180.0, 10.0)); |
| expect(painter.minIntrinsicWidth, 90.0); |
| expect(painter.maxIntrinsicWidth, 180.0); |
| painter.dispose(); |
| }, skip: true); // https://github.com/flutter/flutter/issues/13512 |
| |
| test('TextPainter widget span', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| const text = 'test'; |
| painter.text = const TextSpan( |
| text: text, |
| children: <InlineSpan>[ |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| TextSpan(text: text), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| TextSpan(text: text), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| WidgetSpan(child: SizedBox(width: 50, height: 30)), |
| ], |
| ); |
| |
| // We provide dimensions for the widgets |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(51, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| PlaceholderDimensions( |
| size: Size(50, 30), |
| baselineOffset: 25, |
| alignment: ui.PlaceholderAlignment.bottom, |
| ), |
| ]); |
| |
| painter.layout(maxWidth: 500); |
| |
| // Now, each of the WidgetSpans will have their own placeholder 'hole'. |
| Offset caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 1), ui.Rect.zero); |
| expect(caretOffset.dx, 14); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 4), ui.Rect.zero); |
| expect(caretOffset.dx, 56); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 5), ui.Rect.zero); |
| expect(caretOffset.dx, 106); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 6), ui.Rect.zero); |
| expect(caretOffset.dx, 120); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 10), ui.Rect.zero); |
| expect(caretOffset.dx, 212); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 11), ui.Rect.zero); |
| expect(caretOffset.dx, 262); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 12), ui.Rect.zero); |
| expect(caretOffset.dx, 276); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 13), ui.Rect.zero); |
| expect(caretOffset.dx, 290); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 14), ui.Rect.zero); |
| expect(caretOffset.dx, 304); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 15), ui.Rect.zero); |
| expect(caretOffset.dx, 318); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 16), ui.Rect.zero); |
| expect(caretOffset.dx, 368); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 17), ui.Rect.zero); |
| expect(caretOffset.dx, 418); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 18), ui.Rect.zero); |
| expect(caretOffset.dx, 0); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 19), ui.Rect.zero); |
| expect(caretOffset.dx, 50); |
| caretOffset = painter.getOffsetForCaret(const ui.TextPosition(offset: 23), ui.Rect.zero); |
| expect(caretOffset.dx, 250); |
| |
| expect(painter.inlinePlaceholderBoxes!.length, 14); |
| expect( |
| painter.inlinePlaceholderBoxes![0], |
| const TextBox.fromLTRBD(56, 0, 106, 30, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![2], |
| const TextBox.fromLTRBD(212, 0, 262, 30, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![3], |
| const TextBox.fromLTRBD(318, 0, 368, 30, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![4], |
| const TextBox.fromLTRBD(368, 0, 418, 30, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![5], |
| const TextBox.fromLTRBD(418, 0, 468, 30, TextDirection.ltr), |
| ); |
| // line should break here |
| expect( |
| painter.inlinePlaceholderBoxes![6], |
| const TextBox.fromLTRBD(0, 30, 50, 60, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![7], |
| const TextBox.fromLTRBD(50, 30, 100, 60, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![10], |
| const TextBox.fromLTRBD(200, 30, 250, 60, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![11], |
| const TextBox.fromLTRBD(250, 30, 300, 60, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![12], |
| const TextBox.fromLTRBD(300, 30, 351, 60, TextDirection.ltr), |
| ); |
| expect( |
| painter.inlinePlaceholderBoxes![13], |
| const TextBox.fromLTRBD(351, 30, 401, 60, TextDirection.ltr), |
| ); |
| painter.dispose(); |
| }); |
| |
| // Null values are valid. See https://github.com/flutter/flutter/pull/48346#issuecomment-584839221 |
| test('TextPainter set TextHeightBehavior null test', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| painter.textHeightBehavior = const TextHeightBehavior(); |
| painter.textHeightBehavior = null; |
| painter.dispose(); |
| }); |
| |
| test('TextPainter line metrics', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| const text = 'test1\nhello line two really long for soft break\nfinal line 4'; |
| painter.text = const TextSpan(text: text); |
| |
| painter.layout(maxWidth: 300); |
| |
| expect(painter.text, const TextSpan(text: text)); |
| expect(painter.preferredLineHeight, 14); |
| |
| final List<ui.LineMetrics> lines = painter.computeLineMetrics(); |
| |
| expect(lines.length, 4); |
| |
| expect(lines[0].hardBreak, true); |
| expect(lines[1].hardBreak, false); |
| expect(lines[2].hardBreak, true); |
| expect(lines[3].hardBreak, true); |
| |
| expect(lines[0].ascent, 10.5); |
| expect(lines[1].ascent, 10.5); |
| expect(lines[2].ascent, 10.5); |
| expect(lines[3].ascent, 10.5); |
| |
| expect(lines[0].descent, 3.5); |
| expect(lines[1].descent, 3.5); |
| expect(lines[2].descent, 3.5); |
| expect(lines[3].descent, 3.5); |
| |
| expect(lines[0].unscaledAscent, 10.5); |
| expect(lines[1].unscaledAscent, 10.5); |
| expect(lines[2].unscaledAscent, 10.5); |
| expect(lines[3].unscaledAscent, 10.5); |
| |
| expect(lines[0].baseline, 10.5); |
| expect(lines[1].baseline, 24.5); |
| expect(lines[2].baseline, 38.5); |
| expect(lines[3].baseline, 52.5); |
| |
| expect(lines[0].height, 14); |
| expect(lines[1].height, 14); |
| expect(lines[2].height, 14); |
| expect(lines[3].height, 14); |
| |
| expect(lines[0].width, 70); |
| expect(lines[1].width, 294); |
| expect(lines[2].width, 266); |
| expect(lines[3].width, 168); |
| |
| expect(lines[0].left, 0); |
| expect(lines[1].left, 0); |
| expect(lines[2].left, 0); |
| expect(lines[3].left, 0); |
| |
| expect(lines[0].lineNumber, 0); |
| expect(lines[1].lineNumber, 1); |
| expect(lines[2].lineNumber, 2); |
| expect(lines[3].lineNumber, 3); |
| painter.dispose(); |
| }); |
| |
| group('TextPainter line-height', () { |
| test('half-leading', () { |
| const style = TextStyle( |
| height: 20, |
| fontSize: 1, |
| leadingDistribution: TextLeadingDistribution.even, |
| ); |
| |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = const TextSpan(text: 'A', style: style) |
| ..layout(); |
| |
| final Rect glyphBox = painter |
| .getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)) |
| .first |
| .toRect(); |
| |
| final insets = RelativeRect.fromSize(glyphBox, painter.size); |
| // The glyph box is centered. |
| expect(insets.top, insets.bottom); |
| // The glyph box is exactly 1 logical pixel high. |
| expect(insets.top, (20 - 1) / 2); |
| painter.dispose(); |
| }); |
| |
| test('half-leading with small height', () { |
| const style = TextStyle( |
| height: 0.1, |
| fontSize: 10, |
| leadingDistribution: TextLeadingDistribution.even, |
| ); |
| |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = const TextSpan(text: 'A', style: style) |
| ..layout(); |
| |
| final Rect glyphBox = painter |
| .getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)) |
| .first |
| .toRect(); |
| |
| final insets = RelativeRect.fromSize(glyphBox, painter.size); |
| // The glyph box is still centered. |
| expect(insets.top, insets.bottom); |
| // The glyph box is exactly 10 logical pixel high (the height multiplier |
| // does not scale the glyph). Negative leading. |
| expect(insets.top, (1 - 10) / 2); |
| painter.dispose(); |
| }); |
| |
| test('half-leading with leading trim', () { |
| const style = TextStyle( |
| height: 0.1, |
| fontSize: 10, |
| leadingDistribution: TextLeadingDistribution.even, |
| ); |
| |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = const TextSpan(text: 'A', style: style) |
| ..textHeightBehavior = const TextHeightBehavior( |
| applyHeightToFirstAscent: false, |
| applyHeightToLastDescent: false, |
| ) |
| ..layout(); |
| |
| final Rect glyphBox = painter |
| .getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)) |
| .first |
| .toRect(); |
| |
| expect(painter.size, glyphBox.size); |
| // The glyph box is still centered. |
| expect(glyphBox.topLeft, Offset.zero); |
| painter.dispose(); |
| }); |
| |
| test('TextLeadingDistribution falls back to paragraph style', () { |
| const style = TextStyle(height: 20, fontSize: 1); |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = const TextSpan(text: 'A', style: style) |
| ..textHeightBehavior = const TextHeightBehavior( |
| leadingDistribution: TextLeadingDistribution.even, |
| ) |
| ..layout(); |
| |
| final Rect glyphBox = painter |
| .getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)) |
| .first |
| .toRect(); |
| |
| // Still uses half-leading. |
| final insets = RelativeRect.fromSize(glyphBox, painter.size); |
| expect(insets.top, insets.bottom); |
| expect(insets.top, (20 - 1) / 2); |
| painter.dispose(); |
| }); |
| |
| test('TextLeadingDistribution does nothing if height multiplier is null', () { |
| const style = TextStyle(fontSize: 1); |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = const TextSpan(text: 'A', style: style) |
| ..textHeightBehavior = const TextHeightBehavior( |
| leadingDistribution: TextLeadingDistribution.even, |
| ) |
| ..layout(); |
| |
| final Rect glyphBox = painter |
| .getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)) |
| .first |
| .toRect(); |
| |
| painter.textHeightBehavior = const TextHeightBehavior(); |
| painter.layout(); |
| |
| final Rect newGlyphBox = painter |
| .getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)) |
| .first |
| .toRect(); |
| expect(glyphBox, newGlyphBox); |
| painter.dispose(); |
| }); |
| }); |
| |
| test('TextPainter handles invalid UTF-16', () { |
| FlutterErrorDetails? error; |
| FlutterError.onError = (FlutterErrorDetails details) { |
| error = details; |
| }; |
| |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| const text = 'Hello\uD83DWorld'; |
| const fontSize = 20.0; |
| painter.text = const TextSpan( |
| text: text, |
| style: TextStyle(fontSize: fontSize), |
| ); |
| painter.layout(); |
| // The layout should include one replacement character. |
| expect(painter.width, equals(fontSize)); |
| expect(error!.exception, isNotNull); |
| expect(error!.silent, isTrue); |
| painter.dispose(); |
| }, skip: kIsWeb); // https://github.com/flutter/flutter/issues/87544 |
| |
| test('Diacritic', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| // Two letters followed by a diacritic |
| const text = 'ฟห้'; |
| painter.text = const TextSpan(text: text); |
| painter.layout(); |
| |
| final ui.Offset caretOffset = painter.getOffsetForCaret( |
| const ui.TextPosition(offset: text.length, affinity: TextAffinity.upstream), |
| ui.Rect.zero, |
| ); |
| expect(caretOffset.dx, painter.width); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter line metrics update after layout', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| const text = 'word1 word2 word3'; |
| painter.text = const TextSpan(text: text); |
| |
| painter.layout(maxWidth: 80); |
| |
| List<ui.LineMetrics> lines = painter.computeLineMetrics(); |
| expect(lines.length, 3); |
| |
| painter.layout(maxWidth: 1000); |
| |
| lines = painter.computeLineMetrics(); |
| expect(lines.length, 1); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter throws with stack trace when accessing text layout', () { |
| final painter = TextPainter() |
| ..text = const TextSpan(text: 'TEXT') |
| ..textDirection = TextDirection.ltr; |
| |
| expect( |
| () => painter.getPositionForOffset(Offset.zero), |
| throwsA( |
| isA<FlutterError>().having( |
| (FlutterError error) => error.message, |
| 'message', |
| contains('The TextPainter has never been laid out.'), |
| ), |
| ), |
| ); |
| |
| expect(() { |
| painter.layout(); |
| painter.getPositionForOffset(Offset.zero); |
| }, returnsNormally); |
| |
| expect( |
| () { |
| painter.markNeedsLayout(); |
| painter.getPositionForOffset(Offset.zero); |
| }, |
| throwsA( |
| isA<FlutterError>().having( |
| (FlutterError error) => error.message, |
| 'message', |
| contains('The calls that first invalidated the text layout were:'), |
| ), |
| ), |
| ); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter requires layout after providing different placeholder dimensions', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| painter.text = const TextSpan( |
| children: <InlineSpan>[ |
| TextSpan(text: 'before'), |
| WidgetSpan(child: Text('widget1')), |
| WidgetSpan(child: Text('widget2')), |
| WidgetSpan(child: Text('widget3')), |
| TextSpan(text: 'after'), |
| ], |
| ); |
| |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions(size: Size(30, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(40, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(50, 30), alignment: ui.PlaceholderAlignment.bottom), |
| ]); |
| painter.layout(); |
| |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions(size: Size(30, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(40, 20), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(50, 30), alignment: ui.PlaceholderAlignment.bottom), |
| ]); |
| |
| expect( |
| () => painter.paint(MockCanvas(), Offset.zero), |
| throwsA( |
| isA<StateError>().having( |
| (StateError error) => error.message, |
| 'message', |
| contains('TextPainter.paint called when text geometry was not yet calculated'), |
| ), |
| ), |
| ); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter does not require layout after providing identical placeholder dimensions', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| painter.text = const TextSpan( |
| children: <InlineSpan>[ |
| TextSpan(text: 'before'), |
| WidgetSpan(child: Text('widget1')), |
| WidgetSpan(child: Text('widget2')), |
| WidgetSpan(child: Text('widget3')), |
| TextSpan(text: 'after'), |
| ], |
| ); |
| |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions(size: Size(30, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(40, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(50, 30), alignment: ui.PlaceholderAlignment.bottom), |
| ]); |
| painter.layout(); |
| |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions(size: Size(30, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(40, 30), alignment: ui.PlaceholderAlignment.bottom), |
| PlaceholderDimensions(size: Size(50, 30), alignment: ui.PlaceholderAlignment.bottom), |
| ]); |
| |
| // In tests, paint() will throw an UnimplementedError due to missing drawParagraph method. |
| expect( |
| () => painter.paint(MockCanvas(), Offset.zero), |
| isNot( |
| throwsA( |
| isA<StateError>().having( |
| (StateError error) => error.message, |
| 'message', |
| contains('TextPainter.paint called when text geometry was not yet calculated'), |
| ), |
| ), |
| ), |
| ); |
| painter.dispose(); |
| }); |
| |
| test('TextPainter - debugDisposed', () { |
| final painter = TextPainter(); |
| expect(painter.debugDisposed, false); |
| painter.dispose(); |
| expect(painter.debugDisposed, true); |
| }); |
| |
| test('TextPainter - asserts if disposed more than once', () { |
| final painter = TextPainter()..dispose(); |
| expect(painter.debugDisposed, isTrue); |
| expect(painter.dispose, throwsAssertionError); |
| }); |
| |
| test('TextPainter computeWidth', () { |
| const InlineSpan text = TextSpan(text: 'foobar'); |
| final painter = TextPainter(text: text, textDirection: TextDirection.ltr); |
| painter.layout(); |
| expect(painter.width, TextPainter.computeWidth(text: text, textDirection: TextDirection.ltr)); |
| |
| painter.layout(minWidth: 500); |
| expect( |
| painter.width, |
| TextPainter.computeWidth(text: text, textDirection: TextDirection.ltr, minWidth: 500), |
| ); |
| |
| painter.dispose(); |
| }); |
| |
| test('TextPainter computeMaxIntrinsicWidth', () { |
| const InlineSpan text = TextSpan(text: 'foobar'); |
| final painter = TextPainter(text: text, textDirection: TextDirection.ltr); |
| painter.layout(); |
| expect( |
| painter.maxIntrinsicWidth, |
| TextPainter.computeMaxIntrinsicWidth(text: text, textDirection: TextDirection.ltr), |
| ); |
| |
| painter.layout(minWidth: 500); |
| expect( |
| painter.maxIntrinsicWidth, |
| TextPainter.computeMaxIntrinsicWidth( |
| text: text, |
| textDirection: TextDirection.ltr, |
| minWidth: 500, |
| ), |
| ); |
| |
| painter.dispose(); |
| }); |
| |
| test('TextPainter.getWordBoundary works', () { |
| // Regression test for https://github.com/flutter/flutter/issues/93493 . |
| const testCluster = '👨👩👦👨👩👦👨👩👦'; // 8 * 3 |
| final textPainter = TextPainter( |
| text: const TextSpan(text: testCluster), |
| textDirection: TextDirection.ltr, |
| ); |
| |
| textPainter.layout(); |
| expect( |
| textPainter.getWordBoundary(const TextPosition(offset: 8)), |
| const TextRange(start: 8, end: 16), |
| ); |
| }, skip: isBrowser); // https://github.com/flutter/flutter/issues/61017 |
| |
| test('TextHeightBehavior with strut on empty paragraph', () { |
| // Regression test for https://github.com/flutter/flutter/issues/112123 |
| const style = TextStyle(height: 11, fontSize: 7); |
| const simple = TextSpan(text: 'x', style: style); |
| const emptyString = TextSpan(text: '', style: style); |
| const emptyParagraph = TextSpan(style: style); |
| |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| strutStyle: StrutStyle.fromTextStyle(style, forceStrutHeight: true), |
| textHeightBehavior: const TextHeightBehavior( |
| applyHeightToFirstAscent: false, |
| applyHeightToLastDescent: false, |
| ), |
| ); |
| |
| painter.text = simple; |
| painter.layout(); |
| final double height = painter.height; |
| for (final span in <TextSpan>[simple, emptyString, emptyParagraph]) { |
| painter.text = span; |
| painter.layout(); |
| expect(painter.height, height, reason: '$span is expected to have a height of $height'); |
| expect( |
| painter.preferredLineHeight, |
| height, |
| reason: '$span is expected to have a height of $height', |
| ); |
| } |
| }); |
| |
| test('TextPainter plainText getter', () { |
| final painter = TextPainter()..textDirection = TextDirection.ltr; |
| |
| expect(painter.plainText, ''); |
| |
| painter.text = const TextSpan( |
| children: <InlineSpan>[ |
| TextSpan(text: 'before\n'), |
| WidgetSpan(child: Text('widget')), |
| TextSpan(text: 'after'), |
| ], |
| ); |
| expect(painter.plainText, 'before\n\uFFFCafter'); |
| |
| painter.setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions(size: Size(50, 30), alignment: ui.PlaceholderAlignment.bottom), |
| ]); |
| painter.layout(); |
| expect(painter.plainText, 'before\n\uFFFCafter'); |
| |
| painter.text = const TextSpan( |
| children: <InlineSpan>[ |
| TextSpan(text: 'be\nfo\nre\n'), |
| WidgetSpan(child: Text('widget')), |
| TextSpan(text: 'af\nter'), |
| ], |
| ); |
| expect(painter.plainText, 'be\nfo\nre\n\uFFFCaf\nter'); |
| painter.layout(); |
| expect(painter.plainText, 'be\nfo\nre\n\uFFFCaf\nter'); |
| |
| painter.dispose(); |
| }); |
| |
| test('TextPainter infinite width - centered', () { |
| final painter = TextPainter() |
| ..textAlign = TextAlign.center |
| ..textDirection = TextDirection.ltr; |
| painter.text = const TextSpan(text: 'A', style: TextStyle(fontSize: 10)); |
| var mockCanvas = MockCanvasWithDrawParagraph(); |
| |
| painter.layout(minWidth: double.infinity); |
| expect(painter.width, double.infinity); |
| expect( |
| () => painter.paint(mockCanvas = MockCanvasWithDrawParagraph(), Offset.zero), |
| returnsNormally, |
| ); |
| expect(mockCanvas.centerX, isNull); |
| |
| painter.layout(); |
| expect(painter.width, 10); |
| expect( |
| () => painter.paint(mockCanvas = MockCanvasWithDrawParagraph(), Offset.zero), |
| returnsNormally, |
| ); |
| expect(mockCanvas.centerX, 5); |
| |
| painter.layout(minWidth: 100); |
| expect(painter.width, 100); |
| expect( |
| () => painter.paint(mockCanvas = MockCanvasWithDrawParagraph(), Offset.zero), |
| returnsNormally, |
| ); |
| expect(mockCanvas.centerX, 50); |
| |
| painter.dispose(); |
| }); |
| |
| test('TextPainter infinite width - LTR justified', () { |
| final painter = TextPainter() |
| ..textAlign = TextAlign.justify |
| ..textDirection = TextDirection.ltr; |
| painter.text = const TextSpan(text: 'A', style: TextStyle(fontSize: 10)); |
| var mockCanvas = MockCanvasWithDrawParagraph(); |
| |
| painter.layout(minWidth: double.infinity); |
| expect(painter.width, double.infinity); |
| expect( |
| () => painter.paint(mockCanvas = MockCanvasWithDrawParagraph(), Offset.zero), |
| returnsNormally, |
| ); |
| expect(mockCanvas.offsetX, 0); |
| |
| painter.layout(); |
| expect(painter.width, 10); |
| expect( |
| () => painter.paint(mockCanvas = MockCanvasWithDrawParagraph(), Offset.zero), |
| returnsNormally, |
| ); |
| expect(mockCanvas.offsetX, 0); |
| |
| painter.layout(minWidth: 100); |
| expect(painter.width, 100); |
| expect( |
| () => painter.paint(mockCanvas = MockCanvasWithDrawParagraph(), Offset.zero), |
| returnsNormally, |
| ); |
| expect(mockCanvas.offsetX, 0); |
| |
| painter.dispose(); |
| }); |
| |
| test('LongestLine TextPainter properly relayout when maxWidth changes.', () { |
| // Regression test for https://github.com/flutter/flutter/issues/142309. |
| final painter = TextPainter() |
| ..textAlign = TextAlign.justify |
| ..textWidthBasis = TextWidthBasis.longestLine |
| ..textDirection = TextDirection.ltr |
| ..text = TextSpan(text: 'A' * 100, style: const TextStyle(fontSize: 10)); |
| |
| painter.layout(maxWidth: 1000); |
| expect(painter.width, 1000); |
| |
| painter.layout(maxWidth: 100); |
| expect(painter.width, 100); |
| |
| painter.layout(maxWidth: 1000); |
| expect(painter.width, 1000); |
| }); |
| |
| test('TextPainter line breaking does not round to integers', () { |
| const fontSize = 1.25; |
| const text = '12345'; |
| assert((fontSize * text.length).truncate() != fontSize * text.length); |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan( |
| text: text, |
| style: TextStyle(fontSize: fontSize), |
| ), |
| )..layout(maxWidth: text.length * fontSize); |
| |
| expect(painter.maxIntrinsicWidth, text.length * fontSize); |
| switch (painter.computeLineMetrics()) { |
| case [ui.LineMetrics(width: final double width)]: |
| expect(width, text.length * fontSize); |
| case final List<ui.LineMetrics> metrics: |
| expect(metrics, hasLength(1)); |
| } |
| }); |
| |
| group('strut style', () { |
| test('strut style applies when the span has no style', () { |
| const strut = StrutStyle(height: 10, fontSize: 10); |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan(), |
| strutStyle: strut, |
| )..layout(); |
| expect(painter.height, 100); |
| }); |
| |
| test('strut style leading is a fontSize multiplier', () { |
| const strut = StrutStyle(height: 10, fontSize: 10, leading: 2); |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan(), |
| strutStyle: strut, |
| )..layout(); |
| expect(painter.height, 100 + 20); |
| // Top leading + scaled ascent. |
| expect(painter.computeDistanceToActualBaseline(TextBaseline.alphabetic), 10 + 10 * 7.5); |
| }); |
| |
| test('strut no half leading + force strut height', () { |
| const strut = StrutStyle(height: 10, fontSize: 10, forceStrutHeight: true); |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan(text: 'A', style: TextStyle(fontSize: 20)), |
| strutStyle: strut, |
| )..layout(); |
| expect(painter.height, 100); |
| const double baseline = 75; |
| expect( |
| painter.getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)), |
| const <ui.TextBox>[ |
| TextBox.fromLTRBD(0, baseline - 15, 20, baseline + 5, TextDirection.ltr), |
| ], |
| ); |
| }); |
| |
| test('strut half leading + force strut height', () { |
| const strut = StrutStyle( |
| height: 10, |
| fontSize: 10, |
| forceStrutHeight: true, |
| leadingDistribution: TextLeadingDistribution.even, |
| ); |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan(text: 'A', style: TextStyle(fontSize: 20)), |
| strutStyle: strut, |
| )..layout(); |
| expect(painter.height, 100); |
| const double baseline = 45 + 7.5; |
| expect( |
| painter.getBoxesForSelection(const TextSelection(baseOffset: 0, extentOffset: 1)), |
| const <ui.TextBox>[ |
| TextBox.fromLTRBD(0, baseline - 15, 20, baseline + 5, TextDirection.ltr), |
| ], |
| ); |
| }); |
| |
| test('force strut height applies to widget spans', () { |
| const placeholderSize = Size(1000, 1000); |
| const strut = StrutStyle(height: 10, fontSize: 10, forceStrutHeight: true); |
| final painter = |
| TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const WidgetSpan(child: SizedBox()), |
| strutStyle: strut, |
| ) |
| ..setPlaceholderDimensions(const <PlaceholderDimensions>[ |
| PlaceholderDimensions(size: placeholderSize, alignment: PlaceholderAlignment.bottom), |
| ]) |
| ..layout(); |
| expect(painter.height, 100); |
| }); |
| }); |
| |
| test('getOffsetForCaret does not crash on decomposed characters', () { |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan(text: '각', style: TextStyle(fontSize: 10)), |
| )..layout(maxWidth: 1); // Force the jamo characters to soft wrap. |
| expect( |
| () => painter.getOffsetForCaret(const TextPosition(offset: 0), Rect.zero), |
| returnsNormally, |
| ); |
| }); |
| |
| test('kTextHeightNone unsets the text height multiplier', () { |
| final painter = TextPainter( |
| textDirection: TextDirection.ltr, |
| text: const TextSpan( |
| style: TextStyle(fontSize: 10, height: 1000), |
| children: <TextSpan>[ |
| TextSpan( |
| text: 'A', |
| style: TextStyle(height: kTextHeightNone), |
| ), |
| ], |
| ), |
| )..layout(); |
| expect(painter.height, 10); |
| }); |
| |
| test('debugPaintTextLayoutBoxes', () { |
| const span = TextSpan( |
| text: 'M', |
| // ascent = 96, descent = 32 |
| style: TextStyle(fontSize: 128), |
| children: <InlineSpan>[TextSpan(text: 'M', style: TextStyle(fontSize: 64))], |
| ); |
| |
| final painter = TextPainter() |
| ..textDirection = TextDirection.ltr |
| ..text = span |
| ..layout(); |
| expect( |
| (Canvas canvas) { |
| painter.debugPaintTextLayoutBoxes = true; |
| painter.paint(canvas, Offset.zero); |
| painter.debugPaintTextLayoutBoxes = false; |
| }, |
| paints |
| ..rect(rect: Offset.zero & const Size.square(128)) |
| ..rect(rect: const Offset(128, 96 - 48) & const Size.square(64)), |
| ); |
| }); |
| |
| test('TextPainter dispatches memory events', () async { |
| await expectLater( |
| await memoryEvents(() => TextPainter().dispose(), TextPainter), |
| areCreateAndDispose, |
| ); |
| }); |
| } |
| |
| class MockCanvas extends Fake implements Canvas {} |
| |
| class MockCanvasWithDrawParagraph extends Fake implements Canvas { |
| double? centerX; |
| double? offsetX; |
| @override |
| void drawParagraph(ui.Paragraph paragraph, Offset offset) { |
| offsetX = offset.dx; |
| centerX = offset.dx + paragraph.width / 2; |
| } |
| } |
