您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
1875 行
68 KiB
1875 行
68 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Unity.UIWidgets.async;
|
|
using Unity.UIWidgets.foundation;
|
|
using Unity.UIWidgets.gestures;
|
|
using Unity.UIWidgets.painting;
|
|
using Unity.UIWidgets.rendering;
|
|
using Unity.UIWidgets.service;
|
|
using Unity.UIWidgets.services;
|
|
using Unity.UIWidgets.ui;
|
|
using UnityEngine;
|
|
using Canvas = Unity.UIWidgets.ui.Canvas;
|
|
using Color = Unity.UIWidgets.ui.Color;
|
|
using Rect = Unity.UIWidgets.ui.Rect;
|
|
using StrutStyle = Unity.UIWidgets.painting.StrutStyle;
|
|
|
|
namespace Unity.UIWidgets.rendering {
|
|
class EditableUtils {
|
|
public static readonly float _kCaretGap = 1.0f;
|
|
public static readonly float _kCaretHeightOffset = 2.0f;
|
|
public static readonly Offset _kFloatingCaretSizeIncrease = new Offset(0.5f, 1.0f);
|
|
public static readonly float _kFloatingCaretRadius = 1.0f;
|
|
|
|
public static bool _isWhitespace(int codeUnit) {
|
|
switch (codeUnit) {
|
|
case 0x9: // horizontal tab
|
|
case 0xA: // line feed
|
|
case 0xB: // vertical tab
|
|
case 0xC: // form feed
|
|
case 0xD: // carriage return
|
|
case 0x1C: // file separator
|
|
case 0x1D: // group separator
|
|
case 0x1E: // record separator
|
|
case 0x1F: // unit separator
|
|
case 0x20: // space
|
|
case 0xA0: // no-break space
|
|
case 0x1680: // ogham space mark
|
|
case 0x2000: // en quad
|
|
case 0x2001: // em quad
|
|
case 0x2002: // en space
|
|
case 0x2003: // em space
|
|
case 0x2004: // three-per-em space
|
|
case 0x2005: // four-er-em space
|
|
case 0x2006: // six-per-em space
|
|
case 0x2007: // figure space
|
|
case 0x2008: // punctuation space
|
|
case 0x2009: // thin space
|
|
case 0x200A: // hair space
|
|
case 0x202F: // narrow no-break space
|
|
case 0x205F: // medium mathematical space
|
|
case 0x3000: // ideographic space
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public delegate void SelectionChangedHandler(TextSelection selection, RenderEditable renderObject,
|
|
SelectionChangedCause cause);
|
|
|
|
public delegate void CaretChangedHandler(Rect caretRect);
|
|
|
|
public enum SelectionChangedCause {
|
|
tap,
|
|
doubleTap,
|
|
longPress,
|
|
forcePress,
|
|
keyboard,
|
|
drag
|
|
}
|
|
|
|
public class TextSelectionPoint {
|
|
public readonly Offset point;
|
|
public readonly TextDirection? direction;
|
|
|
|
public TextSelectionPoint(Offset point, TextDirection? direction) {
|
|
D.assert(point != null);
|
|
this.point = point;
|
|
this.direction = direction;
|
|
}
|
|
|
|
public override string ToString() {
|
|
switch (direction) {
|
|
case TextDirection.ltr:
|
|
return $"{point}-ltr";
|
|
case TextDirection.rtl:
|
|
return $"{point}-rtl";
|
|
}
|
|
|
|
return $"{point}";
|
|
|
|
}
|
|
}
|
|
|
|
public class RenderEditable : RelayoutWhenSystemFontsChangeMixinRenderBox {
|
|
public RenderEditable(
|
|
TextSpan text = null,
|
|
TextDirection? textDirection = null,
|
|
TextAlign textAlign = TextAlign.start,
|
|
Color cursorColor = null,
|
|
Color backgroundCursorColor = null,
|
|
ValueNotifier<bool> showCursor = null,
|
|
bool? hasFocus = null,
|
|
LayerLink startHandleLayerLink = null,
|
|
LayerLink endHandleLayerLink = null,
|
|
int? maxLines = 1,
|
|
int? minLines = null,
|
|
bool expands = false,
|
|
StrutStyle strutStyle = null,
|
|
Color selectionColor = null,
|
|
float textScaleFactor = 1.0f,
|
|
TextSelection selection = null,
|
|
ViewportOffset offset = null,
|
|
SelectionChangedHandler onSelectionChanged = null,
|
|
CaretChangedHandler onCaretChanged = null,
|
|
bool ignorePointer = false,
|
|
bool readOnly = false,
|
|
bool forceLine = true,
|
|
TextWidthBasis textWidthBasis = TextWidthBasis.parent,
|
|
bool obscureText = false,
|
|
Locale locale = null,
|
|
float cursorWidth = 1.0f,
|
|
Radius cursorRadius = null,
|
|
bool paintCursorAboveText = false,
|
|
Offset cursorOffset = null,
|
|
float devicePixelRatio = 1.0f,
|
|
ui.BoxHeightStyle selectionHeightStyle = ui.BoxHeightStyle.tight,
|
|
ui.BoxWidthStyle selectionWidthStyle = ui.BoxWidthStyle.tight,
|
|
bool? enableInteractiveSelection = null,
|
|
EdgeInsets floatingCursorAddedMargin = null,
|
|
TextSelectionDelegate textSelectionDelegate = null)
|
|
{
|
|
floatingCursorAddedMargin = floatingCursorAddedMargin ?? EdgeInsets.fromLTRB(4, 4, 4, 5);
|
|
|
|
D.assert(textDirection != null, () => "RenderEditable created without a textDirection.");
|
|
D.assert(maxLines == null || maxLines > 0);
|
|
D.assert(minLines == null || minLines > 0);
|
|
D.assert(startHandleLayerLink != null);
|
|
D.assert(endHandleLayerLink != null);
|
|
D.assert(
|
|
(maxLines == null) || (minLines == null) || (maxLines >= minLines), ()=>
|
|
"minLines can't be greater than maxLines"
|
|
);
|
|
|
|
D.assert(
|
|
!expands || (maxLines == null && minLines == null),()=>
|
|
"minLines and maxLines must be null when expands is true."
|
|
);
|
|
|
|
D.assert(offset != null);
|
|
|
|
D.assert(textSelectionDelegate != null);
|
|
D.assert( cursorWidth >= 0.0);
|
|
|
|
_textPainter = new TextPainter(
|
|
text: text,
|
|
textAlign: textAlign,
|
|
textDirection: textDirection ?? TextDirection.ltr,
|
|
textScaleFactor: textScaleFactor,
|
|
locale: locale,
|
|
strutStyle: strutStyle,
|
|
textWidthBasis: textWidthBasis
|
|
);
|
|
_cursorColor = cursorColor;
|
|
_backgroundCursorColor = backgroundCursorColor;
|
|
_showCursor = showCursor ?? new ValueNotifier<bool>(false);
|
|
_maxLines = maxLines;
|
|
_minLines = minLines;
|
|
_expands = expands;
|
|
_selectionColor = selectionColor;
|
|
_selection = selection;
|
|
_offset = offset;
|
|
_cursorWidth = cursorWidth;
|
|
_cursorRadius = cursorRadius;
|
|
_paintCursorOnTop = paintCursorAboveText;
|
|
_cursorOffset = cursorOffset;
|
|
_floatingCursorAddedMargin = floatingCursorAddedMargin;
|
|
_enableInteractiveSelection = enableInteractiveSelection;
|
|
_devicePixelRatio = devicePixelRatio;
|
|
_selectionHeightStyle = selectionHeightStyle;
|
|
_selectionWidthStyle = selectionWidthStyle;
|
|
_startHandleLayerLink = startHandleLayerLink;
|
|
_endHandleLayerLink = endHandleLayerLink;
|
|
_obscureText = obscureText;
|
|
_readOnly = readOnly;
|
|
_forceLine = forceLine;
|
|
D.assert(_showCursor != null);
|
|
D.assert(!_showCursor.value || cursorColor != null);
|
|
this.hasFocus = hasFocus ?? false;
|
|
this.ignorePointer = ignorePointer;
|
|
this.onCaretChanged = onCaretChanged;
|
|
this.onSelectionChanged = onSelectionChanged;
|
|
this.textSelectionDelegate = textSelectionDelegate;
|
|
|
|
|
|
D.assert(_maxLines == null || _maxLines > 0);
|
|
D.assert(_showCursor != null);
|
|
D.assert(!_showCursor.value || cursorColor != null);
|
|
_doubleTap = new DoubleTapGestureRecognizer(this);
|
|
}
|
|
|
|
public static readonly char obscuringCharacter = '•';
|
|
public SelectionChangedHandler onSelectionChanged;
|
|
float? _textLayoutLastMaxWidth;
|
|
float? _textLayoutLastMinWidth;
|
|
public CaretChangedHandler onCaretChanged;
|
|
public bool ignorePointer;
|
|
|
|
public TextWidthBasis textWidthBasis {
|
|
get {
|
|
return _textPainter.textWidthBasis;
|
|
}
|
|
set {
|
|
D.assert(value != null);
|
|
if (_textPainter.textWidthBasis == value)
|
|
return;
|
|
_textPainter.textWidthBasis = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
public ui.BoxHeightStyle selectionHeightStyle {
|
|
get {
|
|
return _selectionHeightStyle;
|
|
}
|
|
set {
|
|
D.assert(value != null);
|
|
if (_selectionHeightStyle == value)
|
|
return;
|
|
_selectionHeightStyle = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
ui.BoxHeightStyle _selectionHeightStyle;
|
|
|
|
public ui.BoxWidthStyle selectionWidthStyle {
|
|
get {
|
|
return _selectionWidthStyle;
|
|
}
|
|
set {
|
|
D.assert(value != null);
|
|
if (_selectionWidthStyle == value)
|
|
return;
|
|
_selectionWidthStyle = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
ui.BoxWidthStyle _selectionWidthStyle;
|
|
|
|
public LayerLink startHandleLayerLink {
|
|
get {
|
|
return _startHandleLayerLink;
|
|
}
|
|
set {
|
|
if (_startHandleLayerLink == value)
|
|
return;
|
|
_startHandleLayerLink = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
LayerLink _startHandleLayerLink;
|
|
|
|
public LayerLink endHandleLayerLink {
|
|
get {
|
|
return _endHandleLayerLink;
|
|
}
|
|
set {
|
|
if (_endHandleLayerLink == value)
|
|
return;
|
|
_endHandleLayerLink = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
LayerLink _endHandleLayerLink;
|
|
|
|
public bool forceLine {
|
|
get {
|
|
return _forceLine;
|
|
}
|
|
set {
|
|
D.assert(value != null);
|
|
if (_forceLine == value)
|
|
return;
|
|
_forceLine = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
bool _forceLine = false;
|
|
|
|
public bool readOnly {
|
|
get {
|
|
return _readOnly;
|
|
}
|
|
set {
|
|
D.assert(value != null);
|
|
if (_readOnly == value)
|
|
return;
|
|
_readOnly = value;
|
|
}
|
|
}
|
|
|
|
bool _readOnly = false;
|
|
|
|
float _devicePixelRatio;
|
|
|
|
public float devicePixelRatio {
|
|
get { return _devicePixelRatio; }
|
|
set {
|
|
if (devicePixelRatio == value) {
|
|
return;
|
|
}
|
|
|
|
_devicePixelRatio = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
bool _obscureText;
|
|
|
|
public bool obscureText {
|
|
get { return _obscureText; }
|
|
set {
|
|
if (_obscureText == value) {
|
|
return;
|
|
}
|
|
|
|
_obscureText = value;
|
|
}
|
|
}
|
|
|
|
public TextSelectionDelegate textSelectionDelegate;
|
|
public GlobalKeyEventHandlerDelegate globalKeyEventHandler;
|
|
Rect _lastCaretRect;
|
|
|
|
|
|
public ValueListenable<bool> selectionStartInViewport {
|
|
get { return _selectionStartInViewport; }
|
|
}
|
|
|
|
readonly ValueNotifier<bool> _selectionStartInViewport = new ValueNotifier<bool>(true);
|
|
|
|
public ValueListenable<bool> selectionEndInViewport {
|
|
get { return _selectionEndInViewport; }
|
|
}
|
|
|
|
readonly ValueNotifier<bool> _selectionEndInViewport = new ValueNotifier<bool>(true);
|
|
|
|
|
|
DoubleTapGestureRecognizer _doubleTap;
|
|
|
|
void _updateSelectionExtentsVisibility(Offset effectiveOffset) {
|
|
Rect visibleRegion = Offset.zero & size;
|
|
Offset startOffset = _textPainter.getOffsetForCaret(
|
|
new TextPosition(offset: _selection.start, affinity: _selection.affinity),
|
|
_caretPrototype
|
|
);
|
|
|
|
float visibleRegionSlop = 0.5f;
|
|
_selectionStartInViewport.value = visibleRegion
|
|
.inflate(visibleRegionSlop)
|
|
.contains(startOffset + effectiveOffset);
|
|
|
|
Offset endOffset = _textPainter.getOffsetForCaret(
|
|
new TextPosition(offset: _selection.end, affinity: _selection.affinity),
|
|
_caretPrototype
|
|
);
|
|
_selectionEndInViewport.value = visibleRegion
|
|
.inflate(visibleRegionSlop)
|
|
.contains(endOffset + effectiveOffset);
|
|
}
|
|
|
|
int _extentOffset = -1;
|
|
|
|
int _baseOffset = -1;
|
|
|
|
int _previousCursorLocation = -1;
|
|
|
|
bool _resetCursor = false;
|
|
|
|
|
|
void _handleSelectionChange(
|
|
TextSelection nextSelection,
|
|
SelectionChangedCause cause
|
|
) {
|
|
|
|
bool focusingEmpty = nextSelection.baseOffset == 0
|
|
&& nextSelection.extentOffset == 0
|
|
&& !hasFocus;
|
|
if (nextSelection == selection
|
|
&& cause != SelectionChangedCause.keyboard
|
|
&& !focusingEmpty) {
|
|
return;
|
|
}
|
|
|
|
onSelectionChanged?.Invoke(nextSelection, this, cause);
|
|
}
|
|
|
|
void _handleKeyEvent(RawKeyEvent keyEvent) {
|
|
if (keyEvent is RawKeyUpEvent) {
|
|
return;
|
|
}
|
|
|
|
if (selection.isCollapsed) {
|
|
_extentOffset = selection.extentOffset;
|
|
_baseOffset = selection.baseOffset;
|
|
}
|
|
|
|
if (globalKeyEventHandler?.Invoke(keyEvent, false)?.swallow ?? false) {
|
|
return;
|
|
}
|
|
|
|
KeyCode pressedKeyCode = keyEvent.data.unityEvent.keyCode;
|
|
int modifiers = (int) keyEvent.data.unityEvent.modifiers;
|
|
bool shift = (modifiers & (int) EventModifiers.Shift) > 0;
|
|
bool ctrl = (modifiers & (int) EventModifiers.Control) > 0;
|
|
bool alt = (modifiers & (int) EventModifiers.Alt) > 0;
|
|
bool cmd = (modifiers & (int) EventModifiers.Command) > 0;
|
|
|
|
bool rightArrow = pressedKeyCode == KeyCode.RightArrow;
|
|
bool leftArrow = pressedKeyCode == KeyCode.LeftArrow;
|
|
bool upArrow = pressedKeyCode == KeyCode.UpArrow;
|
|
bool downArrow = pressedKeyCode == KeyCode.DownArrow;
|
|
bool arrow = leftArrow || rightArrow || upArrow || downArrow;
|
|
bool aKey = pressedKeyCode == KeyCode.A;
|
|
bool xKey = pressedKeyCode == KeyCode.X;
|
|
bool vKey = pressedKeyCode == KeyCode.V;
|
|
bool cKey = pressedKeyCode == KeyCode.C;
|
|
bool del = pressedKeyCode == KeyCode.Delete;
|
|
bool isMac = SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX;
|
|
|
|
if (keyEvent is RawKeyCommandEvent) {
|
|
// editor case
|
|
_handleShortcuts(((RawKeyCommandEvent) keyEvent).command);
|
|
return;
|
|
}
|
|
|
|
if ((ctrl || (isMac && cmd)) && (xKey || vKey || cKey || aKey)) {
|
|
// runtime case
|
|
if (xKey) {
|
|
_handleShortcuts(KeyCommand.Cut);
|
|
}
|
|
else if (aKey) {
|
|
_handleShortcuts(KeyCommand.SelectAll);
|
|
}
|
|
else if (vKey) {
|
|
_handleShortcuts(KeyCommand.Paste);
|
|
}
|
|
else if (cKey) {
|
|
_handleShortcuts(KeyCommand.Copy);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (arrow) {
|
|
int newOffset = _extentOffset;
|
|
var word = (isMac && alt) || ctrl;
|
|
if (word) {
|
|
newOffset = _handleControl(rightArrow, leftArrow, word, newOffset);
|
|
}
|
|
|
|
newOffset = _handleHorizontalArrows(rightArrow, leftArrow, shift, newOffset);
|
|
if (downArrow || upArrow) {
|
|
newOffset = _handleVerticalArrows(upArrow, downArrow, shift, newOffset);
|
|
}
|
|
|
|
newOffset = _handleShift(rightArrow, leftArrow, shift, newOffset);
|
|
|
|
_extentOffset = newOffset;
|
|
}
|
|
|
|
if (del) {
|
|
_handleDelete();
|
|
}
|
|
}
|
|
|
|
int _handleControl(bool rightArrow, bool leftArrow, bool ctrl, int newOffset) {
|
|
// If control is pressed, we will decide which way to look for a word
|
|
// based on which arrow is pressed.
|
|
if (leftArrow && _extentOffset > 2) {
|
|
TextSelection textSelection =
|
|
_selectWordAtOffset(new TextPosition(offset: _extentOffset - 2));
|
|
newOffset = textSelection.baseOffset + 1;
|
|
}
|
|
else if (rightArrow && _extentOffset < text.text.Length - 2) {
|
|
TextSelection textSelection =
|
|
_selectWordAtOffset(new TextPosition(offset: _extentOffset + 1));
|
|
newOffset = textSelection.extentOffset - 1;
|
|
}
|
|
|
|
return newOffset;
|
|
}
|
|
|
|
int _handleHorizontalArrows(bool rightArrow, bool leftArrow, bool shift, int newOffset) {
|
|
if (rightArrow && _extentOffset < text.text.Length) {
|
|
if (newOffset < text.text.Length - 1 && char.IsHighSurrogate(text.text[newOffset])) {
|
|
// handle emoji, which takes 2 bytes
|
|
newOffset += 2;
|
|
if (shift) {
|
|
_previousCursorLocation += 2;
|
|
}
|
|
}
|
|
else {
|
|
newOffset += 1;
|
|
if (shift) {
|
|
_previousCursorLocation += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (leftArrow && _extentOffset > 0) {
|
|
if (newOffset > 1 && char.IsLowSurrogate(text.text[newOffset - 1])) {
|
|
// handle emoji, which takes 2 bytes
|
|
newOffset -= 2;
|
|
if (shift) {
|
|
_previousCursorLocation -= 2;
|
|
}
|
|
}
|
|
else {
|
|
newOffset -= 1;
|
|
if (shift) {
|
|
_previousCursorLocation -= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return newOffset;
|
|
}
|
|
|
|
int _handleVerticalArrows(bool upArrow, bool downArrow, bool shift, int newOffset) {
|
|
float plh = _textPainter.preferredLineHeight;
|
|
float verticalOffset = upArrow ? -0.5f * plh : 1.5f * plh;
|
|
|
|
Offset caretOffset =
|
|
_textPainter.getOffsetForCaret(new TextPosition(offset: _extentOffset), _caretPrototype);
|
|
Offset caretOffsetTranslated = caretOffset.translate(0.0f, verticalOffset);
|
|
TextPosition position = _textPainter.getPositionForOffset(caretOffsetTranslated);
|
|
|
|
if (position.offset == _extentOffset) {
|
|
if (downArrow) {
|
|
newOffset = text.text.Length;
|
|
}
|
|
else if (upArrow) {
|
|
newOffset = 0;
|
|
}
|
|
|
|
_resetCursor = shift;
|
|
}
|
|
else if (_resetCursor && shift) {
|
|
newOffset = _previousCursorLocation;
|
|
_resetCursor = false;
|
|
}
|
|
else {
|
|
newOffset = position.offset;
|
|
_previousCursorLocation = newOffset;
|
|
}
|
|
|
|
return newOffset;
|
|
}
|
|
|
|
|
|
int _handleShift(bool rightArrow, bool leftArrow, bool shift, int newOffset) {
|
|
if (onSelectionChanged == null) {
|
|
return newOffset;
|
|
}
|
|
|
|
if (shift) {
|
|
if (_baseOffset < newOffset) {
|
|
onSelectionChanged(
|
|
new TextSelection(
|
|
baseOffset: _baseOffset,
|
|
extentOffset: newOffset
|
|
),
|
|
this,
|
|
SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
else {
|
|
onSelectionChanged(
|
|
new TextSelection(
|
|
baseOffset: newOffset,
|
|
extentOffset: _baseOffset
|
|
),
|
|
this,
|
|
SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
if (!selection.isCollapsed) {
|
|
if (leftArrow) {
|
|
newOffset = _baseOffset < _extentOffset ? _baseOffset : _extentOffset;
|
|
}
|
|
else if (rightArrow) {
|
|
newOffset = _baseOffset > _extentOffset ? _baseOffset : _extentOffset;
|
|
}
|
|
}
|
|
|
|
onSelectionChanged(
|
|
TextSelection.fromPosition(
|
|
new TextPosition(
|
|
offset: newOffset
|
|
)
|
|
),
|
|
this,
|
|
SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
|
|
return newOffset;
|
|
}
|
|
|
|
void _handleShortcuts(KeyCommand cmd) {
|
|
switch (cmd) {
|
|
case KeyCommand.Copy:
|
|
if (!selection.isCollapsed) {
|
|
Clipboard.setData(
|
|
new ClipboardData(text: selection.textInside(text.text)));
|
|
}
|
|
|
|
break;
|
|
case KeyCommand.Cut:
|
|
if (!selection.isCollapsed) {
|
|
Clipboard.setData(
|
|
new ClipboardData(text: selection.textInside(text.text)));
|
|
textSelectionDelegate.textEditingValue = new TextEditingValue(
|
|
text: selection.textBefore(text.text)
|
|
+ selection.textAfter(text.text),
|
|
selection: TextSelection.collapsed(offset: selection.start)
|
|
);
|
|
}
|
|
|
|
break;
|
|
case KeyCommand.Paste:
|
|
TextEditingValue value = textSelectionDelegate.textEditingValue;
|
|
Clipboard.getData(Clipboard.kTextPlain).then_(data => {
|
|
if (data != null) {
|
|
textSelectionDelegate.textEditingValue = new TextEditingValue(
|
|
text: value.selection.textBefore(value.text)
|
|
+ data.text
|
|
+ value.selection.textAfter(value.text),
|
|
selection: TextSelection.collapsed(
|
|
offset: value.selection.start + data.text.Length
|
|
)
|
|
);
|
|
}
|
|
});
|
|
|
|
break;
|
|
case KeyCommand.SelectAll:
|
|
_baseOffset = 0;
|
|
_extentOffset = textSelectionDelegate.textEditingValue.text.Length;
|
|
onSelectionChanged(
|
|
new TextSelection(
|
|
baseOffset: 0,
|
|
extentOffset: textSelectionDelegate.textEditingValue.text.Length
|
|
),
|
|
this,
|
|
SelectionChangedCause.keyboard
|
|
);
|
|
break;
|
|
default:
|
|
D.assert(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void _handleDelete() {
|
|
var selection = this.selection;
|
|
if (selection.textAfter(text.text).isNotEmpty()) {
|
|
if (char.IsHighSurrogate(text.text[selection.end])) {
|
|
textSelectionDelegate.textEditingValue = new TextEditingValue(
|
|
text: selection.textBefore(text.text)
|
|
+ selection.textAfter(text.text).Substring(2),
|
|
selection: TextSelection.collapsed(offset: selection.start)
|
|
);
|
|
}
|
|
else {
|
|
textSelectionDelegate.textEditingValue = new TextEditingValue(
|
|
text: selection.textBefore(text.text)
|
|
+ selection.textAfter(text.text).Substring(1),
|
|
selection: TextSelection.collapsed(offset: selection.start)
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
textSelectionDelegate.textEditingValue = new TextEditingValue(
|
|
text: selection.textBefore(text.text),
|
|
selection: TextSelection.collapsed(offset: selection.start)
|
|
);
|
|
}
|
|
}
|
|
|
|
protected void markNeedsTextLayout() {
|
|
_textLayoutLastMaxWidth = null;
|
|
_textLayoutLastMinWidth = null;
|
|
markNeedsLayout();
|
|
}
|
|
|
|
public override void systemFontsDidChange() {
|
|
base.systemFontsDidChange();
|
|
_textPainter.markNeedsLayout();
|
|
_textLayoutLastMaxWidth = null;
|
|
_textLayoutLastMinWidth = null;
|
|
}
|
|
|
|
void _handleSetSelection(TextSelection selection) {
|
|
_handleSelectionChange(selection, SelectionChangedCause.keyboard);
|
|
}
|
|
|
|
void _handleMoveCursorForwardByCharacter(bool extentSelection) {
|
|
int extentOffset = _textPainter.getOffsetAfter(_selection.extentOffset);
|
|
if (extentOffset == null)
|
|
return;
|
|
int baseOffset = !extentSelection ? extentOffset : _selection.baseOffset;
|
|
_handleSelectionChange(
|
|
new TextSelection(baseOffset: baseOffset, extentOffset: extentOffset), SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
|
|
void _handleMoveCursorBackwardByCharacter(bool extentSelection) {
|
|
int extentOffset = _textPainter.getOffsetBefore(_selection.extentOffset);
|
|
if (extentOffset == null)
|
|
return;
|
|
int baseOffset = !extentSelection ? extentOffset : _selection.baseOffset;
|
|
_handleSelectionChange(
|
|
new TextSelection(baseOffset: baseOffset, extentOffset: extentOffset), SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
|
|
void _handleMoveCursorForwardByWord(bool extentSelection) {
|
|
TextRange currentWord = _textPainter.getWordBoundary(_selection.extent);
|
|
if (currentWord == null)
|
|
return;
|
|
TextRange nextWord = _getNextWord(currentWord.end);
|
|
if (nextWord == null)
|
|
return;
|
|
int baseOffset = extentSelection ? _selection.baseOffset : nextWord.start;
|
|
_handleSelectionChange(
|
|
new TextSelection(
|
|
baseOffset: baseOffset,
|
|
extentOffset: nextWord.start
|
|
),
|
|
SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
|
|
void _handleMoveCursorBackwardByWord(bool extentSelection) {
|
|
TextRange currentWord = _textPainter.getWordBoundary(_selection.extent);
|
|
if (currentWord == null)
|
|
return;
|
|
TextRange previousWord = _getPreviousWord(currentWord.start - 1);
|
|
if (previousWord == null)
|
|
return;
|
|
int baseOffset = extentSelection ? _selection.baseOffset : previousWord.start;
|
|
_handleSelectionChange(
|
|
new TextSelection(
|
|
baseOffset: baseOffset,
|
|
extentOffset: previousWord.start
|
|
),
|
|
SelectionChangedCause.keyboard
|
|
);
|
|
}
|
|
|
|
TextRange _getNextWord(int offset) {
|
|
while (true) {
|
|
TextRange range = _textPainter.getWordBoundary(new TextPosition(offset: offset));
|
|
if (range == null || !range.isValid || range.isCollapsed)
|
|
return null;
|
|
if (!_onlyWhitespace(range))
|
|
return range;
|
|
offset = range.end;
|
|
}
|
|
}
|
|
|
|
TextRange _getPreviousWord(int offset) {
|
|
while (offset >= 0) {
|
|
TextRange range = _textPainter.getWordBoundary(new TextPosition(offset: offset));
|
|
if (range == null || !range.isValid || range.isCollapsed)
|
|
return null;
|
|
if (!_onlyWhitespace(range))
|
|
return range;
|
|
offset = range.start - 1;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
bool _onlyWhitespace(TextRange range) {
|
|
for (int i = range.start; i < range.end; i++) {
|
|
int codeUnit = text.codeUnitAt(i) ?? 0;
|
|
if (!EditableUtils._isWhitespace(codeUnit)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
string _cachedPlainText;
|
|
string _plainText {
|
|
get {
|
|
_cachedPlainText = _cachedPlainText ?? _textPainter.text.toPlainText();
|
|
return _cachedPlainText;
|
|
}
|
|
}
|
|
|
|
TextPainter _textPainter;
|
|
|
|
public TextSpan text {
|
|
get { return _textPainter.text as TextSpan; }
|
|
set {
|
|
if (_textPainter.text == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.text = value;
|
|
_cachedPlainText = null;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
public TextAlign textAlign {
|
|
get { return _textPainter.textAlign; }
|
|
set {
|
|
if (_textPainter.textAlign == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.textAlign = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
public TextDirection? textDirection {
|
|
get { return _textPainter.textDirection; }
|
|
set {
|
|
if (_textPainter.textDirection == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.textDirection = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
public StrutStyle strutStyle {
|
|
get { return _textPainter.strutStyle; }
|
|
set {
|
|
if (_textPainter.strutStyle == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.strutStyle = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
Color _cursorColor;
|
|
|
|
public Color cursorColor {
|
|
get { return _cursorColor; }
|
|
set {
|
|
if (_cursorColor == value) {
|
|
return;
|
|
}
|
|
|
|
_cursorColor = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
public Locale locale {
|
|
get { return _textPainter.locale;
|
|
}
|
|
set {
|
|
if (_textPainter.locale == value)
|
|
return;
|
|
_textPainter.locale = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Color _backgroundCursorColor;
|
|
|
|
public Color backgroundCursorColor {
|
|
get { return _backgroundCursorColor; }
|
|
set {
|
|
if (backgroundCursorColor == value) {
|
|
return;
|
|
}
|
|
|
|
_backgroundCursorColor = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
|
|
ValueNotifier<bool> _showCursor;
|
|
|
|
public ValueNotifier<bool> showCursor {
|
|
get { return _showCursor; }
|
|
set {
|
|
D.assert(value != null);
|
|
if (_showCursor == value) {
|
|
return;
|
|
}
|
|
|
|
if (attached) {
|
|
_showCursor.removeListener(markNeedsPaint);
|
|
}
|
|
|
|
_showCursor = value;
|
|
if (attached) {
|
|
_showCursor.addListener(markNeedsPaint);
|
|
}
|
|
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
bool _hasFocus = false;
|
|
bool _listenerAttached = false;
|
|
|
|
public bool hasFocus {
|
|
get { return _hasFocus; }
|
|
set {
|
|
if (_hasFocus == value) {
|
|
return;
|
|
}
|
|
|
|
_hasFocus = value;
|
|
if (_hasFocus) {
|
|
D.assert(!_listenerAttached);
|
|
RawKeyboard.instance.addListener(_handleKeyEvent);
|
|
_listenerAttached = true;
|
|
}
|
|
else {
|
|
D.assert(_listenerAttached);
|
|
RawKeyboard.instance.removeListener(_handleKeyEvent);
|
|
_listenerAttached = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
int? _maxLines;
|
|
|
|
public int? maxLines {
|
|
get { return _maxLines; }
|
|
set {
|
|
D.assert(value == null || value > 0);
|
|
if (_maxLines == value) {
|
|
return;
|
|
}
|
|
|
|
_maxLines = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
int? _minLines;
|
|
|
|
public int? minLines {
|
|
get { return _minLines; }
|
|
set {
|
|
D.assert(value == null || value > 0);
|
|
if (_minLines == value) {
|
|
return;
|
|
}
|
|
|
|
_minLines = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
bool _expands;
|
|
|
|
public bool expands {
|
|
get { return _expands; }
|
|
set {
|
|
if (expands == value) {
|
|
return;
|
|
}
|
|
|
|
_expands = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
Color _selectionColor;
|
|
|
|
public Color selectionColor {
|
|
get { return _selectionColor; }
|
|
set {
|
|
if (_selectionColor == value) {
|
|
return;
|
|
}
|
|
|
|
_selectionColor = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
public float textScaleFactor {
|
|
get { return _textPainter.textScaleFactor; }
|
|
set {
|
|
if (_textPainter.textScaleFactor == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.textScaleFactor = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
List<TextBox> _selectionRects;
|
|
|
|
TextSelection _selection;
|
|
|
|
public TextSelection selection {
|
|
get { return _selection; }
|
|
set {
|
|
if (_selection == value) {
|
|
return;
|
|
}
|
|
|
|
_selection = value;
|
|
_selectionRects = null;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
ViewportOffset _offset;
|
|
|
|
public ViewportOffset offset {
|
|
get { return _offset; }
|
|
set {
|
|
D.assert(offset != null);
|
|
if (_offset == value) {
|
|
return;
|
|
}
|
|
|
|
if (attached) {
|
|
_offset.removeListener(markNeedsPaint);
|
|
}
|
|
|
|
_offset = value;
|
|
if (attached) {
|
|
_offset.addListener(markNeedsPaint);
|
|
}
|
|
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
float _cursorWidth = 1.0f;
|
|
|
|
public float cursorWidth {
|
|
get { return _cursorWidth; }
|
|
set {
|
|
if (_cursorWidth == value) {
|
|
return;
|
|
}
|
|
|
|
_cursorWidth = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
|
|
bool _paintCursorOnTop;
|
|
|
|
public bool paintCursorAboveText {
|
|
get { return _paintCursorOnTop; }
|
|
set {
|
|
if (_paintCursorOnTop == value) {
|
|
return;
|
|
}
|
|
|
|
_paintCursorOnTop = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
Offset _cursorOffset;
|
|
|
|
public Offset cursorOffset {
|
|
get { return _cursorOffset; }
|
|
set {
|
|
if (_cursorOffset == value) {
|
|
return;
|
|
}
|
|
|
|
_cursorOffset = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
Radius _cursorRadius;
|
|
|
|
public Radius cursorRadius {
|
|
get { return _cursorRadius; }
|
|
set {
|
|
if (_cursorRadius == value) {
|
|
return;
|
|
}
|
|
|
|
_cursorRadius = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public EdgeInsets floatingCursorAddedMargin {
|
|
get { return _floatingCursorAddedMargin; }
|
|
set {
|
|
if (_floatingCursorAddedMargin == value) {
|
|
return;
|
|
}
|
|
|
|
_floatingCursorAddedMargin = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
EdgeInsets _floatingCursorAddedMargin;
|
|
|
|
bool _floatingCursorOn = false;
|
|
Offset _floatingCursorOffset;
|
|
TextPosition _floatingCursorTextPosition;
|
|
|
|
|
|
bool? _enableInteractiveSelection;
|
|
|
|
public bool? enableInteractiveSelection {
|
|
get { return _enableInteractiveSelection; }
|
|
set {
|
|
if (_enableInteractiveSelection == value) {
|
|
return;
|
|
}
|
|
|
|
_enableInteractiveSelection = value;
|
|
markNeedsTextLayout();
|
|
}
|
|
}
|
|
|
|
public bool selectionEnabled {
|
|
get { return enableInteractiveSelection ?? !obscureText; }
|
|
}
|
|
|
|
public override void attach(object ownerObject) {
|
|
base.attach(ownerObject);
|
|
_tap = new TapGestureRecognizer(debugOwner: this);
|
|
_tap.onTapDown = _handleTapDown;
|
|
_tap.onTap = _handleTap;
|
|
_longPress = new LongPressGestureRecognizer(debugOwner: this);
|
|
_longPress.onLongPress = _handleLongPress;
|
|
_offset.addListener(markNeedsLayout);
|
|
_showCursor.addListener(markNeedsPaint);
|
|
}
|
|
|
|
public override void detach() {
|
|
_tap.dispose();
|
|
_longPress.dispose();
|
|
_offset.removeListener(markNeedsLayout);
|
|
_showCursor.removeListener(markNeedsPaint);
|
|
if (_listenerAttached) {
|
|
RawKeyboard.instance.removeListener(_handleKeyEvent);
|
|
}
|
|
|
|
base.detach();
|
|
}
|
|
|
|
bool _isMultiline {
|
|
get { return _maxLines != 1; }
|
|
}
|
|
|
|
Axis _viewportAxis {
|
|
get { return _isMultiline ? Axis.vertical : Axis.horizontal; }
|
|
}
|
|
|
|
Offset _paintOffset {
|
|
get {
|
|
switch (_viewportAxis) {
|
|
case Axis.horizontal:
|
|
return new Offset(-offset.pixels, 0.0f);
|
|
case Axis.vertical:
|
|
return new Offset(0.0f, -offset.pixels);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
float _viewportExtent {
|
|
get {
|
|
D.assert(hasSize);
|
|
switch (_viewportAxis) {
|
|
case Axis.horizontal:
|
|
return size.width;
|
|
case Axis.vertical:
|
|
return size.height;
|
|
}
|
|
|
|
return 0.0f;
|
|
}
|
|
}
|
|
|
|
float _getMaxScrollExtent(Size contentSize) {
|
|
D.assert(hasSize);
|
|
switch (_viewportAxis) {
|
|
case Axis.horizontal:
|
|
return Mathf.Max(0.0f, contentSize.width - size.width);
|
|
case Axis.vertical:
|
|
return Mathf.Max(0.0f, contentSize.height - size.height);
|
|
}
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
float _caretMargin {
|
|
get {
|
|
return EditableUtils._kCaretGap + cursorWidth;
|
|
}
|
|
}
|
|
|
|
public float maxScrollExtent {
|
|
get { return _maxScrollExtent; }
|
|
}
|
|
|
|
float _maxScrollExtent = 0;
|
|
bool _hasVisualOverflow {
|
|
get { return _maxScrollExtent > 0 || _paintOffset != Offset.zero; }
|
|
}
|
|
|
|
public List<TextSelectionPoint> getEndpointsForSelection(TextSelection selection) {
|
|
D.assert(constraints != null);
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
var paintOffset = _paintOffset;
|
|
if (selection.isCollapsed) {
|
|
var caretOffset = _textPainter.getOffsetForCaret(selection.extendPos, _caretPrototype);
|
|
var start = new Offset(0.0f, preferredLineHeight) + caretOffset + paintOffset;
|
|
return new List<TextSelectionPoint> {new TextSelectionPoint(start, null)};
|
|
}
|
|
else {
|
|
var boxes = _textPainter.getBoxesForSelection(selection);
|
|
var start = new Offset(boxes[0].start, boxes[0].bottom) + paintOffset;
|
|
var last = boxes.Count - 1;
|
|
var end = new Offset(boxes[last].end, boxes[last].bottom) + paintOffset;
|
|
return new List<TextSelectionPoint> {
|
|
new TextSelectionPoint(start, boxes[0].direction),
|
|
new TextSelectionPoint(end, boxes[last].direction),
|
|
};
|
|
}
|
|
}
|
|
|
|
public TextPosition getPositionForPoint(Offset globalPosition) {
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
globalPosition -= _paintOffset;
|
|
return _textPainter.getPositionForOffset(globalToLocal(globalPosition));
|
|
}
|
|
|
|
public Rect getLocalRectForCaret(TextPosition caretPosition) {
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
var caretOffset = _textPainter.getOffsetForCaret(caretPosition, _caretPrototype);
|
|
Rect rect = Rect.fromLTWH(0.0f, 0.0f, cursorWidth, preferredLineHeight)
|
|
.shift(caretOffset + _paintOffset);
|
|
if (_cursorOffset != null) {
|
|
rect = rect.shift(_cursorOffset);
|
|
}
|
|
|
|
return rect.shift(_getPixelPerfectCursorOffset(rect));
|
|
}
|
|
|
|
protected internal override float computeMinIntrinsicWidth(float height) {
|
|
_layoutText(maxWidth: float.PositiveInfinity);
|
|
return _textPainter.minIntrinsicWidth;
|
|
}
|
|
|
|
protected internal override float computeMaxIntrinsicWidth(float height) {
|
|
_layoutText(maxWidth: float.PositiveInfinity);
|
|
return _textPainter.maxIntrinsicWidth + cursorWidth;
|
|
}
|
|
|
|
public float preferredLineHeight {
|
|
get { return _textPainter.preferredLineHeight; }
|
|
}
|
|
|
|
float _preferredHeight(float width) {
|
|
bool lockedMax = maxLines != null && minLines == null;
|
|
bool lockedBoth = maxLines != null && minLines == maxLines;
|
|
bool singleLine = maxLines == 1;
|
|
if (singleLine || lockedMax || lockedBoth) {
|
|
return preferredLineHeight * maxLines.Value;
|
|
}
|
|
|
|
bool minLimited = minLines != null && minLines > 1;
|
|
bool maxLimited = maxLines != null;
|
|
if (minLimited || maxLimited) {
|
|
_layoutText(maxWidth: width);
|
|
if (minLimited && _textPainter.height < preferredLineHeight * minLines.Value) {
|
|
return preferredLineHeight * minLines.Value;
|
|
}
|
|
|
|
if (maxLimited && _textPainter.height > preferredLineHeight * maxLines.Value) {
|
|
return preferredLineHeight * maxLines.Value;
|
|
}
|
|
}
|
|
|
|
if (!width.isFinite()) {
|
|
var text = _plainText;
|
|
int lines = 1;
|
|
for (int index = 0; index < text.Length; ++index) {
|
|
if (text[index] == 0x0A) {
|
|
lines += 1;
|
|
}
|
|
}
|
|
|
|
return preferredLineHeight * lines;
|
|
}
|
|
|
|
_layoutText(maxWidth: width);
|
|
return Mathf.Max(preferredLineHeight, _textPainter.height);
|
|
}
|
|
|
|
protected internal override float computeMinIntrinsicHeight(float width) {
|
|
return _preferredHeight(width);
|
|
}
|
|
|
|
protected internal override float computeMaxIntrinsicHeight(float width) {
|
|
return _preferredHeight(width);
|
|
}
|
|
|
|
public override float? computeDistanceToActualBaseline(TextBaseline baseline) {
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
return _textPainter.computeDistanceToActualBaseline(baseline);
|
|
}
|
|
|
|
protected override bool hitTestSelf(Offset position) {
|
|
return true;
|
|
}
|
|
|
|
TapGestureRecognizer _tap;
|
|
LongPressGestureRecognizer _longPress;
|
|
|
|
public override void handleEvent(PointerEvent evt, HitTestEntry entry) {
|
|
if (ignorePointer) {
|
|
return;
|
|
}
|
|
|
|
D.assert(debugHandleEvent(evt, entry));
|
|
if (evt is PointerDownEvent && onSelectionChanged != null) {
|
|
_tap.addPointer((PointerDownEvent) evt);
|
|
_doubleTap.addPointer((PointerDownEvent) evt);
|
|
_longPress.addPointer((PointerDownEvent) evt);
|
|
}
|
|
}
|
|
|
|
Offset _lastTapDownPosition;
|
|
|
|
public void handleTapDown(TapDownDetails details) {
|
|
_lastTapDownPosition = details.globalPosition;
|
|
if (!Application.isMobilePlatform) {
|
|
selectPosition(SelectionChangedCause.tap);
|
|
}
|
|
}
|
|
|
|
void _handleTapDown(TapDownDetails details) {
|
|
D.assert(!ignorePointer);
|
|
handleTapDown(details);
|
|
}
|
|
|
|
public void handleTap() {
|
|
selectPosition(cause: SelectionChangedCause.tap);
|
|
}
|
|
|
|
void _handleTap() {
|
|
D.assert(!ignorePointer);
|
|
handleTap();
|
|
}
|
|
|
|
void _handleDoubleTap(DoubleTapDetails details) {
|
|
D.assert(!ignorePointer);
|
|
handleDoubleTap(details);
|
|
}
|
|
|
|
public void handleDoubleTap(DoubleTapDetails details) {
|
|
// need set _lastTapDownPosition, otherwise it would be last single tap position
|
|
_lastTapDownPosition = details.firstGlobalPosition - _paintOffset;
|
|
selectWord(cause: SelectionChangedCause.doubleTap);
|
|
}
|
|
|
|
void _handleLongPress() {
|
|
D.assert(!ignorePointer);
|
|
handleLongPress();
|
|
}
|
|
|
|
public void handleLongPress() {
|
|
selectWord(cause: SelectionChangedCause.longPress);
|
|
}
|
|
|
|
public void selectPositionAt(Offset from = null, Offset to = null, SelectionChangedCause? cause = null) {
|
|
D.assert(cause != null);
|
|
D.assert(from != null);
|
|
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
if (onSelectionChanged == null) {
|
|
return;
|
|
}
|
|
TextPosition fromPosition =
|
|
_textPainter.getPositionForOffset(globalToLocal(from - _paintOffset));
|
|
TextPosition toPosition = to == null
|
|
? null
|
|
: _textPainter.getPositionForOffset(globalToLocal(to - _paintOffset));
|
|
|
|
int baseOffset = fromPosition.offset;
|
|
int extentOffset = fromPosition.offset;
|
|
if (toPosition != null) {
|
|
baseOffset = Mathf.Min(fromPosition.offset, toPosition.offset);
|
|
extentOffset = Mathf.Max(fromPosition.offset, toPosition.offset);
|
|
}
|
|
|
|
TextSelection newSelection = new TextSelection(
|
|
baseOffset: baseOffset,
|
|
extentOffset: extentOffset,
|
|
affinity: fromPosition.affinity);
|
|
|
|
_handleSelectionChange(newSelection, cause.Value);
|
|
}
|
|
|
|
public void selectPosition(SelectionChangedCause? cause = null) {
|
|
selectPositionAt(from: _lastTapDownPosition, cause: cause);
|
|
}
|
|
|
|
public void selectWord(SelectionChangedCause? cause = null) {
|
|
selectWordsInRange(from: _lastTapDownPosition, cause: cause);
|
|
}
|
|
|
|
public void selectWordsInRange(Offset from = null, Offset to = null, SelectionChangedCause? cause = null) {
|
|
D.assert(cause != null);
|
|
D.assert(from != null);
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
if (onSelectionChanged == null) {
|
|
return;
|
|
}
|
|
TextPosition firstPosition =
|
|
_textPainter.getPositionForOffset(globalToLocal(from - _paintOffset));
|
|
TextSelection firstWord = _selectWordAtOffset(firstPosition);
|
|
TextSelection lastWord = to == null
|
|
? firstWord
|
|
: _selectWordAtOffset(
|
|
_textPainter.getPositionForOffset(globalToLocal(to - _paintOffset)));
|
|
|
|
_handleSelectionChange(
|
|
new TextSelection(
|
|
baseOffset: firstWord.baseOffset,
|
|
extentOffset: lastWord.extentOffset,
|
|
affinity: firstWord.affinity),
|
|
cause.Value);
|
|
}
|
|
|
|
public void selectWordEdge(SelectionChangedCause cause) {
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
D.assert(_lastTapDownPosition != null);
|
|
if (onSelectionChanged == null) {
|
|
return;
|
|
}
|
|
TextPosition position =
|
|
_textPainter.getPositionForOffset(
|
|
globalToLocal(_lastTapDownPosition - _paintOffset));
|
|
TextRange word = _textPainter.getWordBoundary(position);
|
|
if (position.offset - word.start <= 1) {
|
|
_handleSelectionChange(
|
|
TextSelection.collapsed(offset: word.start, affinity: TextAffinity.downstream),
|
|
cause
|
|
);
|
|
}
|
|
else {
|
|
_handleSelectionChange(
|
|
TextSelection.collapsed(offset: word.end, affinity: TextAffinity.upstream),
|
|
cause
|
|
);
|
|
}
|
|
}
|
|
|
|
TextSelection _selectWordAtOffset(TextPosition position) {
|
|
D.assert(_textLayoutLastMaxWidth == constraints.maxWidth &&
|
|
_textLayoutLastMinWidth == constraints.minWidth,
|
|
() => $"Last width ({_textLayoutLastMinWidth}, {_textLayoutLastMaxWidth}) not the same as max width constraint ({constraints.minWidth}, {constraints.maxWidth}).");
|
|
var word = _textPainter.getWordBoundary(position);
|
|
if (position.offset >= word.end) {
|
|
return TextSelection.fromPosition(position);
|
|
}
|
|
if (obscureText) {
|
|
return new TextSelection(baseOffset: 0, extentOffset: _plainText.Length);
|
|
}
|
|
return new TextSelection(baseOffset: word.start, extentOffset: word.end);
|
|
}
|
|
|
|
TextSelection _selectLineAtOffset(TextPosition position) {
|
|
D.assert(_textLayoutLastMaxWidth == constraints.maxWidth &&
|
|
_textLayoutLastMinWidth == constraints.minWidth,
|
|
() => $"Last width ({_textLayoutLastMinWidth}, {_textLayoutLastMaxWidth}) not the same as max width constraint ({constraints.minWidth}, {constraints.maxWidth}).");
|
|
TextRange line = _textPainter.getLineBoundary(position);
|
|
if (position.offset >= line.end)
|
|
return TextSelection.fromPosition(position);
|
|
// If text is obscured, the entire string should be treated as one line.
|
|
if (obscureText) {
|
|
return new TextSelection(baseOffset: 0, extentOffset: _plainText.Length);
|
|
}
|
|
return new TextSelection(baseOffset: line.start, extentOffset: line.end);
|
|
}
|
|
|
|
Rect _caretPrototype;
|
|
|
|
void _layoutText( float minWidth = 0.0f, float maxWidth = float.PositiveInfinity ) {
|
|
D.assert(maxWidth != null && minWidth != null);
|
|
if (_textLayoutLastMaxWidth == maxWidth && _textLayoutLastMinWidth == minWidth)
|
|
return;
|
|
float availableMaxWidth = Mathf.Max(0.0f, maxWidth - _caretMargin);
|
|
float availableMinWidth = Mathf.Min(minWidth, availableMaxWidth);
|
|
float textMaxWidth = _isMultiline ? availableMaxWidth : float.PositiveInfinity;
|
|
float textMinWidth = forceLine ? availableMaxWidth : availableMinWidth;
|
|
_textPainter.layout(
|
|
minWidth: textMinWidth,
|
|
maxWidth: textMaxWidth
|
|
);
|
|
_textLayoutLastMinWidth = minWidth;
|
|
_textLayoutLastMaxWidth = maxWidth;
|
|
}
|
|
|
|
Rect _getCaretPrototype {
|
|
get {
|
|
switch (Application.platform) {
|
|
case RuntimePlatform.IPhonePlayer:
|
|
return Rect.fromLTWH(0.0f, 0.0f, cursorWidth,
|
|
preferredLineHeight + 2.0f);
|
|
default:
|
|
return Rect.fromLTWH(0.0f, EditableUtils._kCaretHeightOffset, cursorWidth,
|
|
preferredLineHeight - 2.0f * EditableUtils._kCaretHeightOffset);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
protected override void performLayout() {
|
|
BoxConstraints constraints = this.constraints;
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
_caretPrototype = _getCaretPrototype;
|
|
_selectionRects = null;
|
|
|
|
var textPainterSize = _textPainter.size;
|
|
float width = forceLine ? constraints.maxWidth : constraints
|
|
.constrainWidth(_textPainter.size.width + _caretMargin);
|
|
size = new Size(width, constraints.constrainHeight(_preferredHeight(constraints.maxWidth)));
|
|
Size contentSize = new Size(textPainterSize.width + _caretMargin, textPainterSize.height);
|
|
_maxScrollExtent = _getMaxScrollExtent(contentSize);
|
|
offset.applyViewportDimension(_viewportExtent);
|
|
offset.applyContentDimensions(0.0f, _maxScrollExtent);
|
|
}
|
|
|
|
Offset _getPixelPerfectCursorOffset(Rect caretRect) {
|
|
Offset caretPosition = localToGlobal(caretRect.topLeft);
|
|
float pixelMultiple = 1.0f / _devicePixelRatio;
|
|
int quotientX = (caretPosition.dx / pixelMultiple).round();
|
|
int quotientY = (caretPosition.dy / pixelMultiple).round();
|
|
float pixelPerfectOffsetX = quotientX * pixelMultiple - caretPosition.dx;
|
|
float pixelPerfectOffsetY = quotientY * pixelMultiple - caretPosition.dy;
|
|
return new Offset(pixelPerfectOffsetX, pixelPerfectOffsetY);
|
|
}
|
|
|
|
void _paintCaret(Canvas canvas, Offset effectiveOffset, TextPosition textPosition) {
|
|
D.assert(_textLayoutLastMaxWidth == constraints.maxWidth &&
|
|
_textLayoutLastMinWidth == constraints.minWidth,
|
|
() => $"Last width ({_textLayoutLastMinWidth}, {_textLayoutLastMaxWidth}) not the same as max width constraint ({constraints.minWidth}, {constraints.maxWidth}).");
|
|
var paint = new Paint() {color = _floatingCursorOn ? backgroundCursorColor : _cursorColor};
|
|
var caretOffset = _textPainter.getOffsetForCaret(textPosition, _caretPrototype) + effectiveOffset;
|
|
Rect caretRect = _caretPrototype.shift(caretOffset);
|
|
if (_cursorOffset != null) {
|
|
caretRect = caretRect.shift(_cursorOffset);
|
|
}
|
|
|
|
float? caretHeight = _textPainter.getFullHeightForCaret(textPosition, _caretPrototype);
|
|
if (caretHeight != null) {
|
|
switch (Application.platform) {
|
|
case RuntimePlatform.IPhonePlayer:
|
|
float? heightDiff = caretHeight - caretRect.height;
|
|
caretRect = Rect.fromLTWH(
|
|
caretRect.left,
|
|
(caretRect.top + heightDiff / 2).Value,
|
|
caretRect.width,
|
|
caretRect.height
|
|
);
|
|
break;
|
|
default:
|
|
caretRect = Rect.fromLTWH(
|
|
caretRect.left,
|
|
caretRect.top - EditableUtils._kCaretHeightOffset,
|
|
caretRect.width,
|
|
caretHeight.Value
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
caretRect = caretRect.shift(_getPixelPerfectCursorOffset(caretRect));
|
|
|
|
if (cursorRadius == null) {
|
|
canvas.drawRect(caretRect, paint);
|
|
}
|
|
else {
|
|
RRect caretRRect = RRect.fromRectAndRadius(caretRect, cursorRadius);
|
|
canvas.drawRRect(caretRRect, paint);
|
|
}
|
|
|
|
if (!caretRect.Equals(_lastCaretRect)) {
|
|
_lastCaretRect = caretRect;
|
|
if (onCaretChanged != null) {
|
|
onCaretChanged(caretRect);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setFloatingCursor(FloatingCursorDragState? state, Offset boundedOffset,
|
|
TextPosition lastTextPosition,
|
|
float? resetLerpValue = null) {
|
|
D.assert(boundedOffset != null);
|
|
D.assert(lastTextPosition != null);
|
|
if (state == FloatingCursorDragState.Start) {
|
|
_relativeOrigin = new Offset(0, 0);
|
|
_previousOffset = null;
|
|
_resetOriginOnBottom = false;
|
|
_resetOriginOnTop = false;
|
|
_resetOriginOnRight = false;
|
|
_resetOriginOnBottom = false;
|
|
}
|
|
|
|
_floatingCursorOn = state != FloatingCursorDragState.End;
|
|
_resetFloatingCursorAnimationValue = resetLerpValue;
|
|
if (_floatingCursorOn) {
|
|
_floatingCursorOffset = boundedOffset;
|
|
_floatingCursorTextPosition = lastTextPosition;
|
|
}
|
|
|
|
markNeedsPaint();
|
|
}
|
|
|
|
// describeSemanticsConfiguration todo
|
|
|
|
void _paintFloatingCaret(Canvas canvas, Offset effectiveOffset) {
|
|
D.assert(_textLayoutLastMaxWidth == constraints.maxWidth &&
|
|
_textLayoutLastMinWidth == constraints.minWidth,
|
|
() => $"Last width ({_textLayoutLastMinWidth}, {_textLayoutLastMaxWidth}) not the same as max width constraint ({constraints.minWidth}, {constraints.maxWidth}).");
|
|
D.assert(_floatingCursorOn);
|
|
|
|
Paint paint = new Paint() {color = _cursorColor.withOpacity(0.75f)};
|
|
|
|
float sizeAdjustmentX = EditableUtils._kFloatingCaretSizeIncrease.dx;
|
|
float sizeAdjustmentY = EditableUtils._kFloatingCaretSizeIncrease.dy;
|
|
|
|
if (_resetFloatingCursorAnimationValue != null) {
|
|
sizeAdjustmentX =
|
|
MathUtils.lerpNullableFloat(sizeAdjustmentX, 0f, _resetFloatingCursorAnimationValue.Value);
|
|
sizeAdjustmentY =
|
|
MathUtils.lerpNullableFloat(sizeAdjustmentY, 0f, _resetFloatingCursorAnimationValue.Value);
|
|
}
|
|
|
|
Rect floatingCaretPrototype = Rect.fromLTRB(
|
|
_caretPrototype.left - sizeAdjustmentX,
|
|
_caretPrototype.top - sizeAdjustmentY,
|
|
_caretPrototype.right + sizeAdjustmentX,
|
|
_caretPrototype.bottom + sizeAdjustmentY
|
|
);
|
|
|
|
Rect caretRect = floatingCaretPrototype.shift(effectiveOffset);
|
|
Radius floatingCursorRadius = Radius.circular(EditableUtils._kFloatingCaretRadius);
|
|
RRect caretRRect = RRect.fromRectAndRadius(caretRect, floatingCursorRadius);
|
|
canvas.drawRRect(caretRRect, paint);
|
|
}
|
|
|
|
Offset _relativeOrigin = new Offset(0f, 0f);
|
|
Offset _previousOffset;
|
|
bool _resetOriginOnLeft = false;
|
|
bool _resetOriginOnRight = false;
|
|
bool _resetOriginOnTop = false;
|
|
bool _resetOriginOnBottom = false;
|
|
float? _resetFloatingCursorAnimationValue;
|
|
|
|
public Offset calculateBoundedFloatingCursorOffset(Offset rawCursorOffset) {
|
|
Offset deltaPosition = new Offset(0f, 0f);
|
|
float topBound = -floatingCursorAddedMargin.top;
|
|
float bottomBound = _textPainter.height - preferredLineHeight +
|
|
floatingCursorAddedMargin.bottom;
|
|
float leftBound = -floatingCursorAddedMargin.left;
|
|
float rightBound = _textPainter.width + floatingCursorAddedMargin.right;
|
|
|
|
if (_previousOffset != null) {
|
|
deltaPosition = rawCursorOffset - _previousOffset;
|
|
}
|
|
|
|
if (_resetOriginOnLeft && deltaPosition.dx > 0) {
|
|
_relativeOrigin = new Offset(rawCursorOffset.dx - leftBound, _relativeOrigin.dy);
|
|
_resetOriginOnLeft = false;
|
|
}
|
|
else if (_resetOriginOnRight && deltaPosition.dx < 0) {
|
|
_relativeOrigin = new Offset(rawCursorOffset.dx - rightBound, _relativeOrigin.dy);
|
|
_resetOriginOnRight = false;
|
|
}
|
|
|
|
if (_resetOriginOnTop && deltaPosition.dy > 0) {
|
|
_relativeOrigin = new Offset(_relativeOrigin.dx, rawCursorOffset.dy - topBound);
|
|
_resetOriginOnTop = false;
|
|
}
|
|
else if (_resetOriginOnBottom && deltaPosition.dy < 0) {
|
|
_relativeOrigin = new Offset(_relativeOrigin.dx, rawCursorOffset.dy - bottomBound);
|
|
_resetOriginOnBottom = false;
|
|
}
|
|
|
|
float currentX = rawCursorOffset.dx - _relativeOrigin.dx;
|
|
float currentY = rawCursorOffset.dy - _relativeOrigin.dy;
|
|
float adjustedX = Mathf.Min(Mathf.Max(currentX, leftBound), rightBound);
|
|
float adjustedY = Mathf.Min(Mathf.Max(currentY, topBound), bottomBound);
|
|
Offset adjustedOffset = new Offset(adjustedX, adjustedY);
|
|
|
|
if (currentX < leftBound && deltaPosition.dx < 0) {
|
|
_resetOriginOnLeft = true;
|
|
}
|
|
else if (currentX > rightBound && deltaPosition.dx > 0) {
|
|
_resetOriginOnRight = true;
|
|
}
|
|
|
|
if (currentY < topBound && deltaPosition.dy < 0) {
|
|
_resetOriginOnTop = true;
|
|
}
|
|
else if (currentY > bottomBound && deltaPosition.dy > 0) {
|
|
_resetOriginOnBottom = true;
|
|
}
|
|
|
|
_previousOffset = rawCursorOffset;
|
|
|
|
return adjustedOffset;
|
|
}
|
|
|
|
void _paintSelection(Canvas canvas, Offset effectiveOffset) {
|
|
D.assert(_textLayoutLastMaxWidth == constraints.maxWidth &&
|
|
_textLayoutLastMinWidth == constraints.minWidth,
|
|
() => $"Last width ({_textLayoutLastMinWidth}, {_textLayoutLastMaxWidth}) not the same as max width constraint ({constraints.minWidth}, {constraints.maxWidth}).");
|
|
D.assert(_selectionRects != null);
|
|
var paint = new Paint() {color = _selectionColor};
|
|
|
|
foreach (var box in _selectionRects) {
|
|
canvas.drawRect(box.toRect().shift(effectiveOffset), paint);
|
|
}
|
|
}
|
|
|
|
void _paintContents(PaintingContext context, Offset offset) {
|
|
D.assert(_textLayoutLastMaxWidth == constraints.maxWidth &&
|
|
_textLayoutLastMinWidth == constraints.minWidth,
|
|
() => $"Last width ({_textLayoutLastMinWidth}, {_textLayoutLastMaxWidth}) not the same as max width constraint ({constraints.minWidth}, {constraints.maxWidth}).");
|
|
var effectiveOffset = offset + _paintOffset;
|
|
|
|
bool showSelection = false;
|
|
bool showCaret = false;
|
|
|
|
if (_selection != null && !_floatingCursorOn) {
|
|
if (_selection.isCollapsed && _showCursor.value && cursorColor != null) {
|
|
showCaret = true;
|
|
}
|
|
else if (!_selection.isCollapsed && _selectionColor != null) {
|
|
showSelection = true;
|
|
}
|
|
_updateSelectionExtentsVisibility(effectiveOffset);
|
|
}
|
|
|
|
if (showSelection) {
|
|
_selectionRects = _selectionRects ?? _textPainter.getBoxesForSelection(_selection, boxHeightStyle: _selectionHeightStyle, boxWidthStyle: _selectionWidthStyle);
|
|
_paintSelection(context.canvas, effectiveOffset);
|
|
}
|
|
|
|
if (paintCursorAboveText) {
|
|
_textPainter.paint(context.canvas, effectiveOffset);
|
|
}
|
|
|
|
if (showCaret) {
|
|
_paintCaret(context.canvas, effectiveOffset, _selection.extendPos);
|
|
}
|
|
|
|
if (!paintCursorAboveText) {
|
|
_textPainter.paint(context.canvas, effectiveOffset);
|
|
}
|
|
|
|
if (_floatingCursorOn) {
|
|
if (_resetFloatingCursorAnimationValue == null) {
|
|
_paintCaret(context.canvas, effectiveOffset, _floatingCursorTextPosition);
|
|
}
|
|
|
|
_paintFloatingCaret(context.canvas, _floatingCursorOffset);
|
|
}
|
|
}
|
|
|
|
void _paintHandleLayers(PaintingContext context, List<TextSelectionPoint> endpoints) {
|
|
Offset startPoint = endpoints[0].point;
|
|
startPoint = new Offset(
|
|
startPoint.dx.clamp(0.0f, size.width),
|
|
startPoint.dy.clamp(0.0f, size.height)
|
|
);
|
|
context.pushLayer(
|
|
new LeaderLayer(link: startHandleLayerLink, offset: startPoint),
|
|
base.paint,
|
|
Offset.zero
|
|
);
|
|
if (endpoints.Count == 2) {
|
|
Offset endPoint = endpoints[1].point;
|
|
endPoint = new Offset(
|
|
endPoint.dx.clamp(0.0f, size.width),
|
|
endPoint.dy.clamp(0.0f, size.height)
|
|
);
|
|
context.pushLayer(
|
|
new LeaderLayer(link: endHandleLayerLink, offset: endPoint),
|
|
base.paint,
|
|
Offset.zero
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
public override Rect describeApproximatePaintClip(RenderObject child) {
|
|
return _hasVisualOverflow ? Offset.zero & size : null;
|
|
}
|
|
|
|
public override void paint(PaintingContext context, Offset offset) {
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
if (_hasVisualOverflow) {
|
|
context.pushClipRect(needsCompositing, offset, Offset.zero & size, _paintContents);
|
|
}
|
|
else {
|
|
_paintContents(context, offset);
|
|
_paintHandleLayers(context, getEndpointsForSelection(selection));
|
|
}
|
|
}
|
|
|
|
public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
|
|
base.debugFillProperties(properties);
|
|
properties.add(new ColorProperty("cursorColor", cursorColor));
|
|
properties.add(new DiagnosticsProperty<ValueNotifier<bool>>("showCursor", showCursor));
|
|
properties.add(new DiagnosticsProperty<int?>("maxLines", maxLines));
|
|
properties.add(new DiagnosticsProperty<int?>("minLines", minLines));
|
|
properties.add(new DiagnosticsProperty<bool>("expands", expands));
|
|
properties.add(new ColorProperty("selectionColor", selectionColor));
|
|
properties.add(new DiagnosticsProperty<float>("textScaleFactor", textScaleFactor));
|
|
properties.add(new DiagnosticsProperty<TextSelection>("selection", selection));
|
|
properties.add(new DiagnosticsProperty<ViewportOffset>("offset", offset));
|
|
properties.add(new DiagnosticsProperty<Locale>("locale", locale, defaultValue: null));
|
|
}
|
|
|
|
public override List<DiagnosticsNode> debugDescribeChildren() {
|
|
return new List<DiagnosticsNode> {
|
|
text.toDiagnosticsNode(
|
|
name: "text",
|
|
style: DiagnosticsTreeStyle.transition
|
|
),
|
|
};
|
|
}
|
|
}
|
|
}
|