您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
906 行
34 KiB
906 行
34 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using Unity.UIWidgets.foundation;
|
|
using Unity.UIWidgets.gestures;
|
|
using Unity.UIWidgets.painting;
|
|
using Unity.UIWidgets.service;
|
|
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 {
|
|
public enum TextOverflow {
|
|
clip,
|
|
fade,
|
|
ellipsis,
|
|
visible
|
|
}
|
|
|
|
public class TextParentData : ContainerBoxParentData<RenderBox> {
|
|
public float scale;
|
|
public override string ToString() {
|
|
List<string> values = new List<string>();
|
|
if (offset != null) values.Add("offset=$offset");
|
|
if (scale != null) values.Add("scale=$scale");
|
|
values.Add(base.ToString());
|
|
return string.Join("; ", values);
|
|
}
|
|
}
|
|
public class RenderParagraph : RenderBoxContainerDefaultsMixinContainerRenderObjectMixinRenderBox<RenderBox, TextParentData> {
|
|
static readonly string _kEllipsis = "\u2026";
|
|
|
|
bool _softWrap;
|
|
|
|
TextOverflow _overflow;
|
|
readonly TextPainter _textPainter;
|
|
bool _needsClipping = false;
|
|
ui.Shader _overflowShader;
|
|
|
|
List<TextBox> _selectionRects;
|
|
|
|
public RenderParagraph(
|
|
InlineSpan text = null,
|
|
TextAlign textAlign = TextAlign.start,
|
|
TextDirection textDirection = TextDirection.ltr,
|
|
bool softWrap = true,
|
|
TextOverflow overflow = TextOverflow.clip,
|
|
float textScaleFactor = 1.0f,
|
|
int? maxLines = null,
|
|
Locale locale = null,
|
|
StrutStyle strutStyle = null,
|
|
TextWidthBasis textWidthBasis = TextWidthBasis.parent,
|
|
ui.TextHeightBehavior textHeightBehavior = null,
|
|
List<RenderBox> children = null
|
|
) {
|
|
D.assert(maxLines == null || maxLines > 0);
|
|
D.assert(text != null);
|
|
D.assert(text.debugAssertIsValid());
|
|
D.assert(maxLines == null || maxLines > 0);
|
|
_softWrap = softWrap;
|
|
_overflow = overflow;
|
|
_textPainter = new TextPainter(
|
|
text: text,
|
|
textAlign: textAlign,
|
|
textDirection: textDirection,
|
|
textScaleFactor: textScaleFactor,
|
|
maxLines: maxLines,
|
|
ellipsis: overflow == TextOverflow.ellipsis ? _kEllipsis : null,
|
|
locale: locale,
|
|
strutStyle: strutStyle,
|
|
textWidthBasis: textWidthBasis,
|
|
textHeightBehavior: textHeightBehavior
|
|
);
|
|
//addAll(children);[!!!]?
|
|
_extractPlaceholderSpans(text);
|
|
}
|
|
|
|
public override void setupParentData(RenderObject child) {
|
|
if (!(child.parentData is TextParentData))
|
|
child.parentData = new TextParentData();
|
|
}
|
|
|
|
|
|
public Action onSelectionChanged;
|
|
public Color selectionColor;
|
|
|
|
public TextSelection selection {
|
|
get { return _selection; }
|
|
set {
|
|
if (_selection == value) {
|
|
return;
|
|
}
|
|
|
|
_selection = value;
|
|
_selectionRects = null;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
public InlineSpan text {
|
|
get { return _textPainter.text; }
|
|
|
|
set {
|
|
Debug.Assert(value != null);
|
|
switch (_textPainter.text.compareTo(value)) {
|
|
case RenderComparison.identical:
|
|
case RenderComparison.metadata:
|
|
return;
|
|
case RenderComparison.paint:
|
|
_textPainter.text = value;
|
|
_extractPlaceholderSpans(value);
|
|
markNeedsPaint();
|
|
break;
|
|
case RenderComparison.layout:
|
|
_textPainter.text = value;
|
|
_overflowShader = null;
|
|
_extractPlaceholderSpans(value);
|
|
markNeedsLayout();
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
List<PlaceholderSpan> _placeholderSpans;
|
|
void _extractPlaceholderSpans(InlineSpan span) {
|
|
_placeholderSpans = new List<PlaceholderSpan>();
|
|
span.visitChildren((InlineSpan inlinespan)=> {
|
|
if (inlinespan is PlaceholderSpan) {
|
|
PlaceholderSpan placeholderSpan =(PlaceholderSpan)inlinespan;
|
|
_placeholderSpans.Add(placeholderSpan);
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
public TextAlign textAlign {
|
|
get { return _textPainter.textAlign.Value; }
|
|
set {
|
|
if (_textPainter.textAlign == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.textAlign = value;
|
|
markNeedsPaint();
|
|
}
|
|
}
|
|
|
|
public TextDirection? textDirection {
|
|
get { return _textPainter.textDirection; }
|
|
set {
|
|
if (_textPainter.textDirection == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.textDirection = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
protected Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
|
|
D.assert(_textPainter != null);
|
|
return _textPainter.getOffsetForCaret(position, caretPrototype);
|
|
}
|
|
|
|
List<ui.TextBox> getBoxesForSelection(TextSelection selection) {
|
|
D.assert(!debugNeedsLayout);
|
|
_layoutTextWithConstraints(constraints);
|
|
return _textPainter.getBoxesForSelection(selection);
|
|
}
|
|
|
|
TextPosition getPositionForOffset(Offset offset) {
|
|
D.assert(!debugNeedsLayout);
|
|
_layoutTextWithConstraints(constraints);
|
|
return _textPainter.getPositionForOffset(offset);
|
|
}
|
|
|
|
TextRange getWordBoundary(TextPosition position) {
|
|
D.assert(!debugNeedsLayout);
|
|
_layoutTextWithConstraints(constraints);
|
|
return _textPainter.getWordBoundary(position);
|
|
}
|
|
|
|
public bool softWrap {
|
|
get { return _softWrap; }
|
|
set {
|
|
if (_softWrap == value) {
|
|
return;
|
|
}
|
|
|
|
_softWrap = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public TextOverflow overflow {
|
|
get { return _overflow; }
|
|
set {
|
|
if (_overflow == value) {
|
|
return;
|
|
}
|
|
|
|
_overflow = value;
|
|
_textPainter.ellipsis = value == TextOverflow.ellipsis ? _kEllipsis : null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public float textScaleFactor {
|
|
get { return _textPainter.textScaleFactor; }
|
|
set {
|
|
if (Mathf.Abs(_textPainter.textScaleFactor - value) < 0.00000001) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.textScaleFactor = value;
|
|
_overflowShader = null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public int? maxLines {
|
|
get { return _textPainter.maxLines; }
|
|
set {
|
|
D.assert(maxLines == null || maxLines > 0);
|
|
if (_textPainter.maxLines == value) {
|
|
return;
|
|
}
|
|
|
|
_textPainter.maxLines = value;
|
|
_overflowShader = null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public Locale locale {
|
|
get {
|
|
return _textPainter.locale;
|
|
}
|
|
set {
|
|
if (_textPainter.locale == value)
|
|
return;
|
|
_textPainter.locale = value;
|
|
_overflowShader = null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public StrutStyle strutStyle {
|
|
get { return _textPainter.strutStyle;}
|
|
set {
|
|
if (_textPainter.strutStyle == value)
|
|
return;
|
|
_textPainter.strutStyle = value;
|
|
_overflowShader = null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public TextWidthBasis textWidthBasis {
|
|
get { return _textPainter.textWidthBasis; }
|
|
set {
|
|
if (_textPainter.textWidthBasis == value)
|
|
return;
|
|
_textPainter.textWidthBasis = value;
|
|
_overflowShader = null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
|
|
/// {@macro flutter.dart:ui.textHeightBehavior}
|
|
public ui.TextHeightBehavior textHeightBehavior {
|
|
get {
|
|
return _textPainter.textHeightBehavior;
|
|
}
|
|
set {
|
|
if (_textPainter.textHeightBehavior == value)
|
|
return;
|
|
_textPainter.textHeightBehavior = value;
|
|
_overflowShader = null;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
public Size textSize {
|
|
get { return _textPainter.size; }
|
|
}
|
|
|
|
protected internal override float computeMinIntrinsicWidth(float height) {
|
|
if (!_canComputeIntrinsics()) {
|
|
return 0.0f;
|
|
}
|
|
_computeChildrenWidthWithMinIntrinsics(height);
|
|
_layoutText(); // layout with infinite width.
|
|
return _textPainter.minIntrinsicWidth;
|
|
}
|
|
|
|
protected internal override float computeMaxIntrinsicWidth(float height) {
|
|
if (!_canComputeIntrinsics()) {
|
|
return 0.0f;
|
|
}
|
|
_computeChildrenWidthWithMaxIntrinsics(height);
|
|
_layoutText(); // layout with infinite width.
|
|
return _textPainter.maxIntrinsicWidth;
|
|
}
|
|
|
|
float _computeIntrinsicHeight(float width) {
|
|
if (!_canComputeIntrinsics()) {
|
|
return 0.0f;
|
|
}
|
|
_computeChildrenHeightWithMinIntrinsics(width);
|
|
_layoutText(minWidth: width, maxWidth: width);
|
|
return _textPainter.height;
|
|
}
|
|
|
|
protected internal override float computeMinIntrinsicHeight(float width) {
|
|
return _computeIntrinsicHeight(width);
|
|
}
|
|
|
|
protected internal override float computeMaxIntrinsicHeight(float width) {
|
|
return _computeIntrinsicHeight(width);
|
|
}
|
|
|
|
protected override float? computeDistanceToActualBaseline(TextBaseline baseline) {
|
|
D.assert(!debugNeedsLayout);
|
|
D.assert(constraints != null);
|
|
D.assert(constraints.debugAssertIsValid());
|
|
_layoutTextWithConstraints(constraints);
|
|
return _textPainter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
|
|
}
|
|
|
|
bool _canComputeIntrinsics() {
|
|
foreach (PlaceholderSpan span in _placeholderSpans) {
|
|
switch (span.alignment) {
|
|
case ui.PlaceholderAlignment.baseline:
|
|
case ui.PlaceholderAlignment.aboveBaseline:
|
|
case ui.PlaceholderAlignment.belowBaseline: {
|
|
D.assert(RenderObject.debugCheckingIntrinsics,
|
|
() => "Intrinsics are not available for PlaceholderAlignment.baseline, " +
|
|
"PlaceholderAlignment.aboveBaseline, or PlaceholderAlignment.belowBaseline,");
|
|
return false;
|
|
}
|
|
case ui.PlaceholderAlignment.top:
|
|
case ui.PlaceholderAlignment.middle:
|
|
case ui.PlaceholderAlignment.bottom: {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void _computeChildrenWidthWithMaxIntrinsics(float height) {
|
|
RenderBox child = firstChild;
|
|
List<PlaceholderDimensions> placeholderDimensions = new List<PlaceholderDimensions>(childCount);
|
|
int childIndex = 0;
|
|
while (child != null) {
|
|
placeholderDimensions[childIndex] = new PlaceholderDimensions(
|
|
size: new Size(child.getMaxIntrinsicWidth(height), height),
|
|
alignment: _placeholderSpans[childIndex].alignment,
|
|
baseline: _placeholderSpans[childIndex].baseline.Value,
|
|
baselineOffset:0.0f
|
|
);
|
|
child = childAfter(child);
|
|
childIndex += 1;
|
|
}
|
|
_textPainter.setPlaceholderDimensions(placeholderDimensions);
|
|
}
|
|
|
|
void _computeChildrenWidthWithMinIntrinsics(float height) {
|
|
RenderBox child = firstChild;
|
|
List<PlaceholderDimensions> placeholderDimensions = new List<PlaceholderDimensions>(childCount);
|
|
int childIndex = 0;
|
|
while (child != null) {
|
|
float intrinsicWidth = child.getMinIntrinsicWidth(height);
|
|
float intrinsicHeight = child.getMinIntrinsicHeight(intrinsicWidth);
|
|
placeholderDimensions[childIndex] = new PlaceholderDimensions(
|
|
size: new Size(intrinsicWidth, intrinsicHeight),
|
|
alignment: _placeholderSpans[childIndex].alignment,
|
|
baseline: _placeholderSpans[childIndex].baseline.Value,
|
|
baselineOffset:0.0f
|
|
);
|
|
child = childAfter(child);
|
|
childIndex += 1;
|
|
}
|
|
_textPainter.setPlaceholderDimensions(placeholderDimensions);
|
|
}
|
|
|
|
void _computeChildrenHeightWithMinIntrinsics(float width) {
|
|
RenderBox child = firstChild;
|
|
List<PlaceholderDimensions> placeholderDimensions = new List<PlaceholderDimensions>(childCount);
|
|
int childIndex = 0;
|
|
while (child != null) {
|
|
float intrinsicHeight = child.getMinIntrinsicHeight(width);
|
|
float intrinsicWidth = child.getMinIntrinsicWidth(intrinsicHeight);
|
|
placeholderDimensions[childIndex] = new PlaceholderDimensions(
|
|
size: new Size(intrinsicWidth, intrinsicHeight),
|
|
alignment: _placeholderSpans[childIndex].alignment,
|
|
baseline: _placeholderSpans[childIndex].baseline.Value,
|
|
baselineOffset:0.0f
|
|
);
|
|
child = childAfter(child);
|
|
childIndex += 1;
|
|
}
|
|
_textPainter.setPlaceholderDimensions(placeholderDimensions);
|
|
}
|
|
|
|
protected override bool hitTestSelf(Offset position) {
|
|
return true;
|
|
}
|
|
|
|
protected override bool hitTestChildren(BoxHitTestResult boxHitTestResult, Offset position = null) {
|
|
RenderBox child = firstChild;
|
|
while (child != null) {
|
|
TextParentData textParentData = child.parentData as TextParentData;
|
|
Matrix4 transform = Matrix4.translationValues(
|
|
textParentData.offset.dx,
|
|
textParentData.offset.dy,
|
|
0.0f
|
|
);
|
|
transform.scale(
|
|
textParentData.scale,
|
|
textParentData.scale,
|
|
textParentData.scale
|
|
);
|
|
bool isHit = boxHitTestResult.addWithPaintTransform(
|
|
transform: transform,
|
|
position: position,
|
|
hitTest: (BoxHitTestResult result, Offset transformed) => {
|
|
D.assert(() => {
|
|
Offset manualPosition = (position - textParentData.offset) / textParentData.scale;
|
|
return (transformed.dx - manualPosition.dx).abs() < foundation_.precisionErrorTolerance
|
|
&& (transformed.dy - manualPosition.dy).abs() < foundation_.precisionErrorTolerance;
|
|
});
|
|
return child.hitTest(result, position: transformed);
|
|
}
|
|
);
|
|
if (isHit) {
|
|
return true;
|
|
}
|
|
child = childAfter(child);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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 {
|
|
selection = null;
|
|
D.assert(_listenerAttached);
|
|
RawKeyboard.instance.removeListener(_handleKeyEvent);
|
|
_listenerAttached = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
InlineSpan _previousHoverSpan;
|
|
|
|
#pragma warning disable 0414
|
|
bool _pointerHoverInside;
|
|
#pragma warning restore 0414
|
|
bool _hasHoverRecognizer;
|
|
MouseTrackerAnnotation _hoverAnnotation;
|
|
|
|
/*void _resetHoverHandler() {
|
|
_hasHoverRecognizer = (_textPainter.text as TextSpan)?.hasHoverRecognizer ?? false;
|
|
_previousHoverSpan = null;
|
|
_pointerHoverInside = false;
|
|
|
|
if (_hoverAnnotation != null && attached) {
|
|
RendererBinding.instance.mouseTracker.detachAnnotation(_hoverAnnotation);
|
|
}
|
|
|
|
if (_hasHoverRecognizer) {
|
|
_hoverAnnotation = new MouseTrackerAnnotation(
|
|
onEnter: _onPointerEnter,
|
|
onHover: _onPointerHover,
|
|
onExit: _onPointerExit);
|
|
|
|
if (attached) {
|
|
RendererBinding.instance.mouseTracker.attachAnnotation(_hoverAnnotation);
|
|
}
|
|
}
|
|
else {
|
|
_hoverAnnotation = null;
|
|
}
|
|
}*/
|
|
|
|
void _handleKeyEvent(RawKeyEvent keyEvent) {
|
|
//only allow KCommand.copy
|
|
if (keyEvent is RawKeyUpEvent) {
|
|
return;
|
|
}
|
|
|
|
if (selection.isCollapsed) {
|
|
return;
|
|
}
|
|
|
|
KeyCode pressedKeyCode = keyEvent.data.unityEvent.keyCode;
|
|
int modifiers = (int) keyEvent.data.unityEvent.modifiers;
|
|
bool ctrl = (modifiers & (int) EventModifiers.Control) > 0;
|
|
bool cmd = (modifiers & (int) EventModifiers.Command) > 0;
|
|
bool cKey = pressedKeyCode == KeyCode.C;
|
|
bool isMac = SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX;
|
|
|
|
KeyCommand? kcmd = keyEvent is RawKeyCommandEvent
|
|
? ((RawKeyCommandEvent) keyEvent).command
|
|
: ((ctrl || (isMac && cmd)) && cKey)
|
|
? KeyCommand.Copy
|
|
: (KeyCommand?) null;
|
|
|
|
if (kcmd == KeyCommand.Copy) {
|
|
Clipboard.setData(
|
|
new ClipboardData(text: selection.textInside(text.toPlainText()))
|
|
);
|
|
}
|
|
}
|
|
|
|
public override void attach(object owner) {
|
|
base.attach(owner);
|
|
/*if (_hoverAnnotation != null) {
|
|
RendererBinding.instance.mouseTracker.attachAnnotation(_hoverAnnotation);
|
|
}*/
|
|
}
|
|
|
|
public override void detach() {
|
|
if (_listenerAttached) {
|
|
RawKeyboard.instance.removeListener(_handleKeyEvent);
|
|
}
|
|
|
|
base.detach();
|
|
/*if (_hoverAnnotation != null) {
|
|
RendererBinding.instance.mouseTracker.dispose();//detachAnnotation(_hoverAnnotation);
|
|
}*/
|
|
}
|
|
|
|
TextSelection _selection;
|
|
|
|
public void selectPositionAt(Offset from = null, Offset to = null, SelectionChangedCause? cause = null) {
|
|
D.assert(cause != null);
|
|
D.assert(from != null);
|
|
if (true) {
|
|
TextPosition fromPosition =
|
|
_textPainter.getPositionForOffset(globalToLocal(from));
|
|
TextPosition toPosition = to == null
|
|
? null
|
|
: _textPainter.getPositionForOffset(globalToLocal(to));
|
|
|
|
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);
|
|
|
|
if (newSelection != _selection) {
|
|
_handleSelectionChanged(newSelection, cause.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void _handleSelectionChanged(TextSelection selection,
|
|
SelectionChangedCause cause) {
|
|
this.selection = selection;
|
|
onSelectionChanged?.Invoke();
|
|
}
|
|
|
|
void _onPointerEnter(PointerEvent evt) {
|
|
_pointerHoverInside = true;
|
|
}
|
|
|
|
/*void _onPointerExit(PointerEvent evt) {
|
|
_pointerHoverInside = false;
|
|
(_previousHoverSpan as TextSpan)?.hoverRecognizer?.OnPointerLeave?.Invoke();
|
|
_previousHoverSpan = null;
|
|
}*/
|
|
|
|
/*void _onPointerHover(PointerEvent evt) {
|
|
_layoutTextWithConstraints(constraints);
|
|
Offset offset = globalToLocal(evt.position);
|
|
TextPosition position = _textPainter.getPositionForOffset(offset);
|
|
InlineSpan span = _textPainter.text.getSpanForPosition(position);
|
|
|
|
if (_previousHoverSpan != span) {
|
|
(_previousHoverSpan as TextSpan)?.hoverRecognizer?.OnPointerLeave?.Invoke();
|
|
(span as TextSpan)?.hoverRecognizer?.OnPointerEnter?.Invoke((PointerHoverEvent) evt);
|
|
_previousHoverSpan = span;
|
|
}
|
|
}*/
|
|
|
|
public override void handleEvent(PointerEvent evt, HitTestEntry entry) {
|
|
D.assert(debugHandleEvent(evt, entry));
|
|
if (!(evt is PointerDownEvent)) {
|
|
return;
|
|
}
|
|
|
|
_layoutTextWithConstraints(constraints);
|
|
Offset offset = ((BoxHitTestEntry) entry).localPosition;
|
|
TextPosition position = _textPainter.getPositionForOffset(offset);
|
|
InlineSpan span = _textPainter.text.getSpanForPosition(position);
|
|
if (span == null) {
|
|
return;
|
|
}
|
|
if (span is TextSpan) {
|
|
TextSpan textSpan = (TextSpan)span;
|
|
textSpan.recognizer?.addPointer(evt as PointerDownEvent);
|
|
}
|
|
}
|
|
|
|
bool debugHasOverflowShader {
|
|
get { return _overflowShader != null; }
|
|
}
|
|
|
|
|
|
void _layoutChildren(BoxConstraints constraints) {
|
|
if (childCount == 0) {
|
|
return;
|
|
}
|
|
RenderBox child = firstChild;
|
|
_placeholderDimensions = new List<PlaceholderDimensions>(childCount);
|
|
int childIndex = 0;
|
|
while (child != null) {
|
|
child.layout(
|
|
new BoxConstraints(
|
|
maxWidth: constraints.maxWidth
|
|
),
|
|
parentUsesSize: true
|
|
);
|
|
float baselineOffset;
|
|
switch (_placeholderSpans[childIndex].alignment) {
|
|
case ui.PlaceholderAlignment.baseline: {
|
|
baselineOffset = child.getDistanceToBaseline(
|
|
_placeholderSpans[childIndex].baseline.Value
|
|
).Value;
|
|
break;
|
|
}
|
|
default: {
|
|
baselineOffset = 0.0f;
|
|
break;
|
|
}
|
|
}
|
|
_placeholderDimensions[childIndex] = new PlaceholderDimensions(
|
|
size: child.size,
|
|
alignment: _placeholderSpans[childIndex].alignment,
|
|
baseline: _placeholderSpans[childIndex].baseline.Value,
|
|
baselineOffset: baselineOffset
|
|
);
|
|
child = childAfter(child);
|
|
childIndex += 1;
|
|
}
|
|
}
|
|
|
|
void _setParentData() {
|
|
RenderBox child = firstChild;
|
|
int childIndex = 0;
|
|
while (child != null && childIndex < _textPainter.inlinePlaceholderBoxes.Count) {
|
|
TextParentData textParentData = child.parentData as TextParentData;
|
|
textParentData.offset = new Offset(
|
|
_textPainter.inlinePlaceholderBoxes[childIndex].left,
|
|
_textPainter.inlinePlaceholderBoxes[childIndex].top
|
|
);
|
|
textParentData.scale = _textPainter.inlinePlaceholderScales[childIndex];
|
|
child = childAfter(child);
|
|
childIndex += 1;
|
|
}
|
|
}
|
|
|
|
protected override void performLayout() {
|
|
BoxConstraints constraints = this.constraints;
|
|
_layoutChildren(constraints);
|
|
_layoutTextWithConstraints(constraints);
|
|
_setParentData();
|
|
var textSize = _textPainter.size;
|
|
var textDidExceedMaxLines = _textPainter.didExceedMaxLines;
|
|
size = constraints.constrain(textSize);
|
|
|
|
var didOverflowHeight = size.height < textSize.height || textDidExceedMaxLines;
|
|
var didOverflowWidth = size.width < textSize.width;
|
|
var hasVisualOverflow = didOverflowWidth || didOverflowHeight;
|
|
if (hasVisualOverflow) {
|
|
/*switch (_overflow) {
|
|
case TextOverflow.visible:
|
|
_needsClipping = false;
|
|
break;
|
|
case TextOverflow.clip:
|
|
case TextOverflow.ellipsis:
|
|
case TextOverflow.fade:
|
|
_needsClipping = true;
|
|
break;
|
|
}*/
|
|
switch (_overflow) {
|
|
case TextOverflow.visible:
|
|
_needsClipping = false;
|
|
_overflowShader = null;
|
|
break;
|
|
case TextOverflow.clip:
|
|
case TextOverflow.ellipsis:
|
|
_needsClipping = true;
|
|
_overflowShader = null;
|
|
break;
|
|
case TextOverflow.fade:
|
|
D.assert(textDirection != null);
|
|
_needsClipping = true;
|
|
TextPainter fadeSizePainter = new TextPainter(
|
|
text: new TextSpan(style: _textPainter.text.style, text: "\u2026"),
|
|
textDirection: textDirection.Value,
|
|
textScaleFactor: textScaleFactor,
|
|
locale: locale
|
|
);
|
|
fadeSizePainter.layout();
|
|
if (didOverflowWidth) {
|
|
float fadeEnd = 0, fadeStart = 0;
|
|
switch (textDirection) {
|
|
case TextDirection.rtl:
|
|
fadeEnd = 0.0f;
|
|
fadeStart = fadeSizePainter.width;
|
|
break;
|
|
case TextDirection.ltr:
|
|
fadeEnd = size.width;
|
|
fadeStart = fadeEnd - fadeSizePainter.width;
|
|
break;
|
|
}
|
|
_overflowShader = ui.Gradient.linear(
|
|
new Offset(fadeStart, 0.0f),
|
|
new Offset(fadeEnd, 0.0f),
|
|
new List<Color>{new Color(0xFFFFFFFF), new Color(0x00FFFFFF)}
|
|
);
|
|
} else {
|
|
float fadeEnd = size.height;
|
|
float fadeStart = fadeEnd - fadeSizePainter.height / 2.0f;
|
|
_overflowShader = ui.Gradient.linear(
|
|
new Offset(0.0f, fadeStart),
|
|
new Offset(0.0f, fadeEnd),
|
|
new List<Color> {new Color(0xFFFFFFFF), new Color(0x00FFFFFF)}
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
_needsClipping = false;
|
|
_overflowShader = null;
|
|
}
|
|
}
|
|
|
|
|
|
/*void paintParagraph(PaintingContext context, Offset offset) {
|
|
_layoutTextWithConstraints(constraints);
|
|
var canvas = context.canvas;
|
|
|
|
if (_needsClipping) {
|
|
var bounds = offset & size;
|
|
canvas.save();
|
|
canvas.clipRect(bounds);
|
|
}
|
|
|
|
if (_selection != null && selectionColor != null && _selection.isValid) {
|
|
if (!_selection.isCollapsed) {
|
|
_selectionRects =
|
|
_selectionRects ?? _textPainter.getBoxesForSelection(_selection);
|
|
_paintSelection(canvas, offset);
|
|
}
|
|
}
|
|
|
|
_textPainter.paint(canvas, offset);
|
|
if (_needsClipping) {
|
|
canvas.restore();
|
|
}
|
|
}
|
|
|
|
public override void paint(PaintingContext context, Offset offset) {
|
|
if (_hoverAnnotation != null) {
|
|
AnnotatedRegionLayer<MouseTrackerAnnotation> layer = new AnnotatedRegionLayer<MouseTrackerAnnotation>(
|
|
_hoverAnnotation, size: size, offset: offset);
|
|
|
|
context.pushLayer(layer, paintParagraph, offset);
|
|
}
|
|
else {
|
|
paintParagraph(context, offset);
|
|
}
|
|
} */
|
|
|
|
public override void paint(PaintingContext context2, Offset offset2) {
|
|
_layoutTextWithConstraints(constraints);
|
|
|
|
D.assert(() => {
|
|
if (RenderingDebugUtils.debugRepaintTextRainbowEnabled) {
|
|
Paint paint = new Paint();
|
|
paint.color = RenderingDebugUtils.debugCurrentRepaintColor.toColor();
|
|
context2.canvas.drawRect(offset2 & size, paint);
|
|
}
|
|
return true;
|
|
});
|
|
|
|
if (_needsClipping) {
|
|
Rect bounds = offset2 & size;
|
|
if (_overflowShader != null) {
|
|
context2.canvas.saveLayer(bounds, new Paint());
|
|
} else {
|
|
context2.canvas.save();
|
|
}
|
|
context2.canvas.clipRect(bounds);
|
|
}
|
|
_textPainter.paint(context2.canvas, offset2);
|
|
|
|
RenderBox child = firstChild;
|
|
int childIndex = 0;
|
|
while (child != null && childIndex < _textPainter.inlinePlaceholderBoxes.Count) {
|
|
TextParentData textParentData = child.parentData as TextParentData;
|
|
|
|
float scale = textParentData.scale;
|
|
context2.pushTransform(
|
|
needsCompositing,
|
|
offset2 + textParentData.offset,
|
|
Matrix4.diagonal3Values(scale, scale, scale),
|
|
(PaintingContext context, Offset offset) => {
|
|
context.paintChild(
|
|
child,
|
|
offset
|
|
);
|
|
}
|
|
);
|
|
child = childAfter(child);
|
|
childIndex += 1;
|
|
}
|
|
if (_needsClipping) {
|
|
if (_overflowShader != null) {
|
|
context2.canvas.translate(offset2.dx, offset2.dy);
|
|
Paint paint = new Paint();
|
|
paint.blendMode = BlendMode.modulate;
|
|
paint.shader = _overflowShader;
|
|
context2.canvas.drawRect(Offset.zero & size, paint);
|
|
}
|
|
context2.canvas.restore();
|
|
}
|
|
}
|
|
|
|
|
|
void _paintSelection(Canvas canvas, Offset effectiveOffset) {
|
|
D.assert(_selectionRects != null);
|
|
D.assert(selectionColor != null);
|
|
var paint = new Paint {color = selectionColor};
|
|
|
|
Path barPath = new Path();
|
|
foreach (var box in _selectionRects) {
|
|
barPath.addRect(box.toRect().shift(effectiveOffset));
|
|
}
|
|
|
|
canvas.drawPath(barPath, paint);
|
|
}
|
|
|
|
void _layoutText(float minWidth = 0.0f, float maxWidth = float.PositiveInfinity) {
|
|
var widthMatters = softWrap || overflow == TextOverflow.ellipsis;
|
|
_textPainter.layout(minWidth, widthMatters ? maxWidth : float.PositiveInfinity);
|
|
}
|
|
|
|
List<PlaceholderDimensions> _placeholderDimensions;
|
|
|
|
void _layoutTextWithConstraints(BoxConstraints constraints) {
|
|
_textPainter.setPlaceholderDimensions(_placeholderDimensions);
|
|
_layoutText(minWidth: constraints.minWidth, maxWidth: constraints.maxWidth);
|
|
}
|
|
|
|
public override List<DiagnosticsNode> debugDescribeChildren() {
|
|
return new List<DiagnosticsNode> {
|
|
text.toDiagnosticsNode(name: "text", style: DiagnosticsTreeStyle.transition)
|
|
};
|
|
}
|
|
|
|
public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
|
|
base.debugFillProperties(properties);
|
|
properties.add(new EnumProperty<TextAlign>("textAlign", textAlign));
|
|
properties.add(new EnumProperty<TextDirection?>("textDirection", textDirection));
|
|
properties.add(new FlagProperty("softWrap", value: softWrap, ifTrue: "wrapping at box width",
|
|
ifFalse: "no wrapping except at line break characters", showName: true));
|
|
properties.add(new EnumProperty<TextOverflow>("overflow", overflow));
|
|
properties.add(new FloatProperty("textScaleFactor", textScaleFactor, defaultValue: 1.0f));
|
|
properties.add(new DiagnosticsProperty<Locale>("locale", locale, defaultValue: null));
|
|
properties.add(new IntProperty("maxLines", maxLines, ifNull: "unlimited"));
|
|
}
|
|
}
|
|
}
|