com.unity.uiwidgets/Runtime/painting/text_painter.cs

using System.Collections.Generic;
using Unity.UIWidgets.foundation;
using Unity.UIWidgets.service;
using Unity.UIWidgets.ui;
using UnityEngine;
using Canvas = Unity.UIWidgets.ui.Canvas;
using Rect = Unity.UIWidgets.ui.Rect;

namespace Unity.UIWidgets.painting {
    class _CaretMetrics {
        public _CaretMetrics(Offset offset, float? fullHeight) {
            this.offset = offset;
            this.fullHeight = fullHeight;
        }

        public Offset offset;
        public float? fullHeight;
    }

    public class TextPainter {
        TextSpan _text;
        TextAlign _textAlign;
        TextDirection? _textDirection;
        float _textScaleFactor;
        Paragraph _layoutTemplate;
        Paragraph _paragraph;
        bool _needsLayout = true;
        int? _maxLines;
        string _ellipsis;
        float _lastMinWidth;
        float _lastMaxWidth;

        public TextPainter(TextSpan text = null,
            TextAlign textAlign = TextAlign.left,
            TextDirection textDirection = TextDirection.ltr,
            float textScaleFactor = 1.0f,
            int? maxLines = null,
            string ellipsis = "",
            StrutStyle strutStyle = null) {
            this._text = text;
            this._textAlign = textAlign;
            this._textDirection = textDirection;
            this._textScaleFactor = textScaleFactor;
            this._maxLines = maxLines;
            this._ellipsis = ellipsis;
            this._strutStyle = strutStyle;
        }

        public float textScaleFactor {
            get { return this._textScaleFactor; }
            set {
                if (this._textScaleFactor == value) {
                    return;
                }

                this._textScaleFactor = value;
                this._layoutTemplate = null;
                this._needsLayout = true;
                Paragraph.release(ref this._paragraph);
            }
        }

        public string ellipsis {
            get { return this._ellipsis; }
            set {
                if (this._ellipsis == value) {
                    return;
                }

                this._ellipsis = value;
                Paragraph.release(ref this._paragraph);
                this._needsLayout = true;
            }
        }

        public TextSpan text {
            get { return this._text; }
            set {
                if ((this._text == null && value == null) || (this._text != null && this.text.Equals(value))) {
                    return;
                }

                if (!Equals(this._text == null ? null : this._text.style, value == null ? null : value.style)) {
                    this._layoutTemplate = null;
                }

                this._text = value;
                Paragraph.release(ref this._paragraph);
                this._needsLayout = true;
            }
        }

        public Size size {
            get {
                Debug.Assert(!this._needsLayout);
                return new Size(this.width, this.height);
            }
        }

        public TextDirection? textDirection {
            get { return this._textDirection; }
            set {
                if (this.textDirection == value) {
                    return;
                }

                this._textDirection = value;
                Paragraph.release(ref this._paragraph);
                this._layoutTemplate = null;
                this._needsLayout = true;
            }
        }

        public TextAlign textAlign {
            get { return this._textAlign; }
            set {
                if (this._textAlign == value) {
                    return;
                }

                this._textAlign = value;
                Paragraph.release(ref this._paragraph);
                this._needsLayout = true;
            }
        }

        public bool didExceedMaxLines {
            get {
                Debug.Assert(!this._needsLayout);
                return this._paragraph.didExceedMaxLines;
            }
        }

        public int? maxLines {
            get { return this._maxLines; }
            set {
                if (this._maxLines == value) {
                    return;
                }

                this._maxLines = value;
                Paragraph.release(ref this._paragraph);
                this._needsLayout = true;
            }
        }

        public StrutStyle strutStyle {
            get { return this._strutStyle; }
            set {
                if (this._strutStyle == value) {
                    return;
                }

                this._strutStyle = value;
                this._paragraph = null;
                this._needsLayout = true;
            }
        }

        StrutStyle _strutStyle;

        public float minIntrinsicWidth {
            get {
                Debug.Assert(!this._needsLayout);
                return this._applyFloatingPointHack(this._paragraph.minIntrinsicWidth);
            }
        }

        public float maxIntrinsicWidth {
            get {
                Debug.Assert(!this._needsLayout);
                return this._applyFloatingPointHack(this._paragraph.maxIntrinsicWidth);
            }
        }

        public float height {
            get {
                Debug.Assert(!this._needsLayout);
                return this._applyFloatingPointHack(this._paragraph.height);
            }
        }

        public float width {
            get {
                Debug.Assert(!this._needsLayout);
                return this._applyFloatingPointHack(this._paragraph.width);
            }
        }

        public float computeDistanceToActualBaseline(TextBaseline baseline) {
            Debug.Assert(!this._needsLayout);
            switch (baseline) {
                case TextBaseline.alphabetic:
                    return this._paragraph.alphabeticBaseline;
                case TextBaseline.ideographic:
                    return this._paragraph.ideographicBaseline;
            }

            return 0.0f;
        }

        public void layout(float minWidth = 0.0f, float maxWidth = float.PositiveInfinity) {
            Debug.Assert(this.text != null,
                "TextPainter.text must be set to a non-null value before using the TextPainter.");
            Debug.Assert(this.textDirection != null,
                "TextPainter.textDirection must be set to a non-null value before using the TextPainter.");
            if (!this._needsLayout && minWidth == this._lastMinWidth && maxWidth == this._lastMaxWidth) {
                return;
            }

            this._needsLayout = false;
            if (this._paragraph == null) {
                var builder = new ParagraphBuilder(this._createParagraphStyle());
                this._text.build(builder, this.textScaleFactor);
                this._paragraph = builder.build();
            }

            this._lastMinWidth = minWidth;
            this._lastMaxWidth = maxWidth;
            this._paragraph.layout(new ParagraphConstraints(maxWidth));

            if (minWidth != maxWidth) {
                var newWidth = MathUtils.clamp(this.maxIntrinsicWidth, minWidth, maxWidth);
                if (newWidth != this.width) {
                    this._paragraph.layout(new ParagraphConstraints(newWidth));
                }
            }
        }

        public void paint(Canvas canvas, Offset offset) {
            Debug.Assert(!this._needsLayout);
            this._paragraph.paint(canvas, offset);
        }

        public Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
            this._computeCaretMetrics(position, caretPrototype);
            return this._caretMetrics.offset;
        }

        public float? getFullHeightForCaret(TextPosition position, Rect caretPrototype) {
            this._computeCaretMetrics(position, caretPrototype);
            return this._caretMetrics.fullHeight;
        }

        _CaretMetrics _caretMetrics;

        TextPosition _previousCaretPosition;
        Rect _previousCaretPrototype;

        void _computeCaretMetrics(TextPosition position, Rect caretPrototype) {
            D.assert(!this._needsLayout);
            if (position == this._previousCaretPosition && caretPrototype == this._previousCaretPrototype) {
                return;
            }

            var offset = position.offset;
            Rect rect;
            switch (position.affinity) {
                case TextAffinity.upstream:
                    rect = this._getRectFromUpstream(offset, caretPrototype) ??
                           this._getRectFromDownStream(offset, caretPrototype);
                    break;
                case TextAffinity.downstream:
                    rect = this._getRectFromDownStream(offset, caretPrototype) ??
                           this._getRectFromUpstream(offset, caretPrototype);
                    break;
                default:
                    throw new UIWidgetsError("Unknown Position Affinity");
            }

            this._caretMetrics = new _CaretMetrics(
                offset: rect != null ? new Offset(rect.left, rect.top) : this._emptyOffset,
                fullHeight: rect != null ? (float?) (rect.bottom - rect.top) : null);
            
            // Cache the caret position. This was forgot in flutter until https://github.com/flutter/flutter/pull/38821
            this._previousCaretPosition = position;
            this._previousCaretPrototype = caretPrototype;
        }

        public Paragraph.LineRange getLineRange(int lineNumber) {
            D.assert(!this._needsLayout);
            return this._paragraph.getLineRange(lineNumber);
        }

        public Paragraph.LineRange getLineRange(TextPosition textPosition) {
            return this.getLineRange(this.getLineIndex(textPosition));
        }

        public List<TextBox> getBoxesForSelection(TextSelection selection) {
            D.assert(!this._needsLayout);
            var results = this._paragraph.getRectsForRange(selection.start, selection.end);
            return results;
        }

        public TextPosition getPositionForOffset(Offset offset) {
            D.assert(!this._needsLayout);
            var result = this._paragraph.getGlyphPositionAtCoordinate(offset.dx, offset.dy);
            return new TextPosition(result.position, result.affinity);
        }

        public TextRange getWordBoundary(TextPosition position) {
            D.assert(!this._needsLayout);
            var range = this._paragraph.getWordBoundary(position.offset);
            return new TextRange(range.start, range.end);
        }

        public TextPosition getPositionVerticalMove(TextPosition position, int move) {
            D.assert(!this._needsLayout);
            var offset = this.getOffsetForCaret(position, Rect.zero);
            var lineIndex = Mathf.Min(Mathf.Max(this._paragraph.getLine(position) + move, 0),
                this._paragraph.getLineCount() - 1);
            var targetLineStart = this._paragraph.getLineRange(lineIndex).start;
            var newLineOffset = this.getOffsetForCaret(new TextPosition(targetLineStart), Rect.zero);
            return this.getPositionForOffset(new Offset(offset.dx, newLineOffset.dy));
        }

        public int getLineIndex(TextPosition position) {
            D.assert(!this._needsLayout);
            return this._paragraph.getLine(position);
        }

        public int getLineCount() {
            D.assert(!this._needsLayout);
            return this._paragraph.getLineCount();
        }

        public TextPosition getWordRight(TextPosition position) {
            D.assert(!this._needsLayout);
            var offset = position.offset;
            while (true) {
                var range = this._paragraph.getWordBoundary(offset);
                if (range.end == range.start) {
                    break;
                }

                if (!char.IsWhiteSpace((char) (this.text.codeUnitAt(range.start) ?? 0))) {
                    return new TextPosition(range.end);
                }

                offset = range.end;
            }

            return new TextPosition(offset, position.affinity);
        }

        public TextPosition getWordLeft(TextPosition position) {
            D.assert(!this._needsLayout);
            var offset = Mathf.Max(position.offset - 1, 0);
            while (true) {
                var range = this._paragraph.getWordBoundary(offset);
                if (!char.IsWhiteSpace((char) (this.text.codeUnitAt(range.start) ?? 0))) {
                    return new TextPosition(range.start);
                }

                offset = Mathf.Max(range.start - 1, 0);
                if (offset == 0) {
                    break;
                }
            }

            return new TextPosition(offset, position.affinity);
        }

        ParagraphStyle _createParagraphStyle(TextDirection defaultTextDirection = TextDirection.ltr) {
            if (this._text.style == null) {
                return new ParagraphStyle(
                    textAlign: this.textAlign,
                    textDirection: this.textDirection ?? defaultTextDirection,
                    maxLines: this.maxLines,
                    ellipsis: this.ellipsis,
                    strutStyle: this._strutStyle
                );
            }

            return this._text.style.getParagraphStyle(this.textAlign, this.textDirection ?? defaultTextDirection,
                this.ellipsis, this.maxLines, this.textScaleFactor);
        }

        public float preferredLineHeight {
            get {
                if (this._layoutTemplate == null) {
                    var builder = new ParagraphBuilder(this._createParagraphStyle(TextDirection.ltr)
                    ); // direction doesn't matter, text is just a space
                    if (this.text != null && this.text.style != null) {
                        builder.pushStyle(this.text.style, this.textScaleFactor);
                    }

                    builder.addText(" ");
                    this._layoutTemplate = builder.build();
                    this._layoutTemplate.layout(new ParagraphConstraints(float.PositiveInfinity));
                }

                return this._layoutTemplate.height;
            }
        }

        float _applyFloatingPointHack(float layoutValue) {
            return Mathf.Ceil(layoutValue);
        }

        const int _zwjUtf16 = 0x200d;

        Rect _getRectFromUpstream(int offset, Rect caretPrototype) {
            string flattenedText = this._text.toPlainText();
            var prevCodeUnit = this._text.codeUnitAt(Mathf.Max(0, offset - 1));
            if (prevCodeUnit == null) {
                return null;
            }

            bool needsSearch = _isUtf16Surrogate(prevCodeUnit.Value) || this._text.codeUnitAt(offset) == _zwjUtf16;
            int graphemeClusterLength = needsSearch ? 2 : 1;
            List<TextBox> boxes = null;
            while ((boxes == null || boxes.isEmpty()) && flattenedText != null) {
                int prevRuneOffset = offset - graphemeClusterLength;
                boxes = this._paragraph.getRectsForRange(prevRuneOffset, offset);
                if (boxes.isEmpty()) {
                    if (!needsSearch) {
                        break;
                    }

                    if (prevRuneOffset < -flattenedText.Length) {
                        break;
                    }

                    graphemeClusterLength *= 2;
                    continue;
                }

                TextBox box = boxes[0];
                const int NEWLINE_CODE_UNIT = 10;
                if (prevCodeUnit == NEWLINE_CODE_UNIT) {
                    return Rect.fromLTRB(this._emptyOffset.dx, box.bottom,
                        this._emptyOffset.dx, box.bottom + box.bottom - box.top);
                }

                float caretEnd = box.end;
                float dx = box.direction == TextDirection.rtl ? caretEnd - caretPrototype.width : caretEnd;
                return Rect.fromLTRB(Mathf.Min(dx, this.width), box.top,
                    Mathf.Min(dx, this.width), box.bottom);
            }

            return null;
        }

        Rect _getRectFromDownStream(int offset, Rect caretPrototype) {
            string flattenedText = this._text.toPlainText();
            var nextCodeUnit =
                this._text.codeUnitAt(Mathf.Min(offset, flattenedText == null ? 0 : flattenedText.Length - 1));
            if (nextCodeUnit == null) {
                return null;
            }

            bool needsSearch = _isUtf16Surrogate(nextCodeUnit.Value) || nextCodeUnit == _zwjUtf16;
            int graphemeClusterLength = needsSearch ? 2 : 1;
            List<TextBox> boxes = null;
            while ((boxes == null || boxes.isEmpty()) && flattenedText != null) {
                int nextRuneOffset = offset + graphemeClusterLength;
                boxes = this._paragraph.getRectsForRange(offset, nextRuneOffset);
                if (boxes.isEmpty()) {
                    if (!needsSearch) {
                        break;
                    }

                    if (nextRuneOffset >= flattenedText.Length << 1) {
                        break;
                    }

                    graphemeClusterLength *= 2;
                    continue;
                }

                TextBox box = boxes[boxes.Count - 1];
                float caretStart = box.start;
                float dx = box.direction == TextDirection.rtl ? caretStart - caretPrototype.width : caretStart;
                return Rect.fromLTRB(Mathf.Min(dx, this.width), box.top,
                    Mathf.Min(dx, this.width), box.bottom);
            }

            return null;
        }

        Offset _emptyOffset {
            get {
                D.assert(!this._needsLayout);
                switch (this.textAlign) {
                    case TextAlign.left:
                        return Offset.zero;
                    case TextAlign.right:
                        return new Offset(this.width, 0.0f);
                    case TextAlign.center:
                        return new Offset(this.width / 2.0f, 0.0f);
                    case TextAlign.justify:
                        if (this.textDirection == TextDirection.rtl) {
                            return new Offset(this.width, 0.0f);
                        }

                        return Offset.zero;
                }

                return null;
            }
        }

        static bool _isUtf16Surrogate(int value) {
            return (value & 0xF800) == 0xD800;
        }
    }
}