浏览代码

Merge branch 'shiyun/skia' into shiyun/cupertino/skia

/siyaoH-1.17-PlatformMessage
Shiyun Wen 4 年前
当前提交
ea82d49d
共有 18 个文件被更改,包括 292 次插入283 次删除
  1. 2
      com.unity.uiwidgets/Runtime/gestures/hit_test.cs
  2. 4
      com.unity.uiwidgets/Runtime/painting/placeholder_span.cs
  3. 4
      com.unity.uiwidgets/Runtime/painting/text_painter.cs
  4. 4
      com.unity.uiwidgets/Runtime/rendering/editable.cs
  5. 12
      com.unity.uiwidgets/Runtime/rendering/flex.cs
  6. 14
      com.unity.uiwidgets/Runtime/rendering/paragraph.cs
  7. 9
      com.unity.uiwidgets/Runtime/rendering/shifted_box.cs
  8. 119
      com.unity.uiwidgets/Runtime/rendering/sliver.cs
  9. 95
      com.unity.uiwidgets/Runtime/rendering/sliver_fill.cs
  10. 95
      com.unity.uiwidgets/Runtime/rendering/sliver_fixed_extent_list.cs
  11. 40
      com.unity.uiwidgets/Runtime/rendering/sliver_grid.cs
  12. 2
      com.unity.uiwidgets/Runtime/rendering/sliver_list.cs
  13. 11
      com.unity.uiwidgets/Runtime/rendering/sliver_multi_box_adaptor.cs
  14. 11
      com.unity.uiwidgets/Runtime/rendering/sliver_padding.cs
  15. 83
      com.unity.uiwidgets/Runtime/rendering/sliver_persistent_header.cs
  16. 62
      com.unity.uiwidgets/Runtime/rendering/stack.cs
  17. 6
      com.unity.uiwidgets/Runtime/widgets/editable_text.cs
  18. 2
      com.unity.uiwidgets/Runtime/widgets/widget_span.cs

2
com.unity.uiwidgets/Runtime/gestures/hit_test.cs


}
bool _debugVectorMoreOrLessEquals(Vector4 a, Vector4 b,
double epsilon = SliverGeometry.precisionErrorTolerance) {
double epsilon = foundation_.precisionErrorTolerance) {
bool result = true;
D.assert(() => {
Vector4 difference = a - b;

4
com.unity.uiwidgets/Runtime/painting/placeholder_span.cs


namespace Unity.UIWidgets.painting {
abstract class PlaceholderSpan : InlineSpan {
public PlaceholderSpan(
TextBaseline? baseline = null,
TextBaseline baseline = TextBaseline.alphabetic,
TextStyle style = null,
PlaceholderAlignment alignment = PlaceholderAlignment.bottom

public PlaceholderAlignment alignment;
public TextBaseline? baseline;
public TextBaseline baseline;
public override void computeToPlainText(
StringBuilder buffer,

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


public class TextPainter {
InlineSpan _text;
TextAlign? _textAlign;
TextAlign _textAlign;
TextDirection? _textDirection;
float _textScaleFactor;
Paragraph _layoutTemplate;

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

4
com.unity.uiwidgets/Runtime/rendering/editable.cs


bool _onlyWhitespace(TextRange range) {
for (int i = range.start; i < range.end; i++) {
int codeUnit = text.codeUnitAt(i).Value;
int codeUnit = text.codeUnitAt(i) ?? 0;
if (!EditableUtils._isWhitespace(codeUnit)) {
return false;
}

}
}
public TextAlign? textAlign {
public TextAlign textAlign {
get { return _textPainter.textAlign; }
set {
if (_textPainter.textAlign == value) {

12
com.unity.uiwidgets/Runtime/rendering/flex.cs


}
public float _getIntrinsicSize(
Axis? sizingDirection = null,
float? extent = null,
_ChildSizingFunction childSize = null
Axis sizingDirection,
float extent,
_ChildSizingFunction childSize
) {
if (_direction == sizingDirection) {
float totalFlex = 0.0f;

int flex = _getFlex(child);
totalFlex += flex;
if (flex > 0) {
float flexFraction = childSize(child, extent.Value) / _getFlex(child);
float flexFraction = childSize(child, extent) / _getFlex(child);
inflexibleSpace += childSize(child, extent.Value);
inflexibleSpace += childSize(child, extent);
}
var childParentData = (FlexParentData) child.parentData;

child = childParentData.nextSibling;
}
float spacePerFlex = Mathf.Max(0.0f, ((availableMainSpace - inflexibleSpace) / totalFlex).Value);
float spacePerFlex = Mathf.Max(0.0f, ((availableMainSpace - inflexibleSpace) / totalFlex) ?? 0.0f);
child = firstChild;
while (child != null) {

14
com.unity.uiwidgets/Runtime/rendering/paragraph.cs


}
public TextAlign textAlign {
get { return _textPainter.textAlign.Value; }
get { return _textPainter.textAlign; }
set {
if (_textPainter.textAlign == value) {
return;

placeholderDimensions[childIndex] = new PlaceholderDimensions(
size: new Size(child.getMaxIntrinsicWidth(height), height),
alignment: _placeholderSpans[childIndex].alignment,
baseline: _placeholderSpans[childIndex].baseline.Value,
baseline: _placeholderSpans[childIndex].baseline,
baselineOffset:0.0f
);
child = childAfter(child);

placeholderDimensions[childIndex] = new PlaceholderDimensions(
size: new Size(intrinsicWidth, intrinsicHeight),
alignment: _placeholderSpans[childIndex].alignment,
baseline: _placeholderSpans[childIndex].baseline.Value,
baseline: _placeholderSpans[childIndex].baseline,
baselineOffset:0.0f
);
child = childAfter(child);

placeholderDimensions[childIndex] = new PlaceholderDimensions(
size: new Size(intrinsicWidth, intrinsicHeight),
alignment: _placeholderSpans[childIndex].alignment,
baseline: _placeholderSpans[childIndex].baseline.Value,
baseline: _placeholderSpans[childIndex].baseline,
baselineOffset:0.0f
);
child = childAfter(child);

switch (_placeholderSpans[childIndex].alignment) {
case ui.PlaceholderAlignment.baseline: {
baselineOffset = child.getDistanceToBaseline(
_placeholderSpans[childIndex].baseline.Value
).Value;
_placeholderSpans[childIndex].baseline
) ?? 0.0f;
break;
}
default: {

_placeholderDimensions[childIndex] = new PlaceholderDimensions(
size: child.size,
alignment: _placeholderSpans[childIndex].alignment,
baseline: _placeholderSpans[childIndex].baseline.Value,
baseline: _placeholderSpans[childIndex].baseline,
baselineOffset: baselineOffset
);
child = childAfter(child);

9
com.unity.uiwidgets/Runtime/rendering/shifted_box.cs


D.assert(!debugNeedsLayout);
result = child.getDistanceToActualBaseline(baseline);
var childParentData = (BoxParentData) child.parentData;
var childParentData = (BoxParentData) child.parentData;
result += childParentData.offset.dy;
}
}

protected override void performLayout() {
size = constraints.constrain(_requestedSize);
if (child != null) {
child.layout(constraints);
child.layout(constraints, parentUsesSize: true);
alignChild();
}
}

public float baseline {
get { return _baseline; }
set {
D.assert(value != null);
if (_baseline == value) {
return;
}

public TextBaseline baselineType {
get { return _baselineType; }
set {
D.assert(value != null);
if (_baselineType == value) {
return;
}

protected override void performLayout() {
if (child != null) {
BoxConstraints constraints = this.constraints;
float top = actualBaseline - childBaseline.Value;
float top = actualBaseline - (childBaseline ?? 0.0f);
var childParentData = (BoxParentData) child.parentData;
childParentData.offset = new Offset(0.0f, top);
Size childSize = child.size;

119
com.unity.uiwidgets/Runtime/rendering/sliver.cs


}
diagnosticInfo.Add(new DiagnosticsProperty<SliverConstraints>("The offending constraints were", this, style: DiagnosticsTreeStyle.errorProperty));
throw new UIWidgetsError(
diagnosticInfo);
throw new UIWidgetsError(diagnosticInfo);
}
return true;
});

if (ReferenceEquals(this, other)) {
return true;
}
D.assert(other.debugAssertIsValid());
return axisDirection == other.axisDirection
&& growthDirection == other.growthDirection
&& userScrollDirection == other.userScrollDirection

}
public override string ToString() {
string result = "";
result += ($"{axisDirection}") +" , ";
result +=($"{growthDirection}")+" , ";
result +=($"{userScrollDirection}")+" , ";
result +=($"scrollOffset: {scrollOffset : F1}")+" , ";
result +=($"remainingPaintExtent: {remainingPaintExtent : F1}")+" , ";
if (overlap != 0.0)
result +=($"overlap: {overlap: F1}")+" , ";
result +=($"crossAxisExtent: {crossAxisExtent : F1}")+" , ";
result +=($"crossAxisDirection: crossAxisDirection")+" , ";
result +=($"viewportMainAxisExtent: {viewportMainAxisExtent : F1}")+" , ";
result +=($"remainingCacheExtent: {remainingCacheExtent : F1}")+" , ";
result +=($"cacheOrigin: {cacheOrigin : F1}");
return $"SliverConstraints({result})";
return
$"SliverConstraints({axisDirection}, {growthDirection}, {userScrollDirection}, scrollOffset: {scrollOffset:F1}, remainingPaintExtent: {remainingCacheExtent:F1}, " +
$"{(overlap != 0.0f ? "overlap: " + overlap.ToString("F1") + ", " : "")}crossAxisExtent: {crossAxisExtent:F1}, crossAxisDirection: {crossAxisDirection}, " +
$"viewportMainAxisExtent: {viewportMainAxisExtent:F1}, remainingCacheExtent: {remainingCacheExtent:F1} " +
$"cacheOrigin: {cacheOrigin:F1})";
List<string> properties = new List<string>();
properties.Add($"{axisDirection}");
properties.Add($"{growthDirection}");
properties.Add($"{userScrollDirection}");
properties.Add($"scrollOffset: {scrollOffset : F1}");
properties.Add($"remainingPaintExtent: {remainingPaintExtent : F1}");
if (overlap != 0.0)
properties.Add($"overlap: {overlap: F1}");
properties.Add($"crossAxisExtent: {crossAxisExtent : F1}");
properties.Add($"crossAxisDirection: {crossAxisDirection}");
properties.Add($"viewportMainAxisExtent: {viewportMainAxisExtent : F1}");
properties.Add($"remainingCacheExtent: {remainingCacheExtent : F1}");
properties.Add($"cacheOrigin: {cacheOrigin : F1}");
return $"SliverConstraints({string.Join(", ",properties)})";
}
}

public readonly bool hasVisualOverflow;
public readonly float? scrollOffsetCorrection;
public readonly float cacheExtent;
public const float precisionErrorTolerance = 1e-10f;
internal static List<DiagnosticsNode> _debugCompareFloats(string labelA, float valueA, string labelB, float valueB) {
List<DiagnosticsNode> diagnosticInfo = new List<DiagnosticsNode>();

);
}
if (paintExtent - maxPaintExtent > precisionErrorTolerance) {
if (paintExtent - maxPaintExtent > foundation_.precisionErrorTolerance) {
var details = _debugCompareFloats("maxPaintExtent", maxPaintExtent, "paintExtent",
paintExtent);
details.Add(new ErrorDescription("By definition, a sliver can\"t paint more than the maximum that it can paint!"));

}
public bool addWithAxisOffset(
Offset paintOffset,
SliverHitTest hitTest
Offset paintOffset = null,
SliverHitTest hitTest = null
D.assert(mainAxisOffset != null);
D.assert(crossAxisOffset != null);
D.assert(mainAxisPosition != null);
D.assert(crossAxisPosition != null);
D.assert(hitTest != null);
if (paintOffset != null) {
pushTransform(Matrix4.translationValues(-paintOffset.dx, -paintOffset.dy, 0));

}
public class SliverHitTestEntry : HitTestEntry {
public SliverHitTestEntry(RenderSliver target,
public SliverHitTestEntry(
RenderSliver target,
float mainAxisPosition = 0.0f,
float crossAxisPosition = 0.0f
) : base(target) {

}
D.assert(!debugDoingThisResize);
string contract = "", violation = "", hint = "";
DiagnosticsNode contract, violation, hint = null;
violation = "It appears that the geometry setter was called from performLayout().";
hint = "";
violation = new ErrorDescription("It appears that the geometry setter was called from performLayout().");
violation =
"The geometry setter was called from outside layout (neither performResize() nor performLayout() were being run for this object).";
violation = new ErrorDescription("The geometry setter was called from outside layout (neither performResize() nor performLayout() were being run for this object).");
hint =
"Only the object itself can set its geometry. It is a contract violation for other objects to set it.";
hint = new ErrorDescription("Only the object itself can set its geometry. It is a contract violation for other objects to set it.");
contract =
"Because this RenderSliver has sizedByParent set to true, it must set its geometry in performResize().";
contract = new ErrorDescription("Because this RenderSliver has sizedByParent set to true, it must set its geometry in performResize().");
contract =
"Because this RenderSliver has sizedByParent set to false, it must set its geometry in performLayout().";
contract = new ErrorDescription(
"Because this RenderSliver has sizedByParent set to false, it must set its geometry in performLayout().");
throw new UIWidgetsError(
"RenderSliver geometry setter called incorrectly.\n" +
violation + "\n" +
hint + "\n" +
contract + "\n" +
"The RenderSliver in question is:\n" +
" " + this
);
List<DiagnosticsNode> information = new List<DiagnosticsNode>();
information.Add(new ErrorSummary("RenderSliver geometry setter called incorrectly."));
information.Add(violation);
if (hint != null) {
information.Add(hint);
}
information.Add(contract);
information.Add(describeForError("The RenderSliver in question is"));
throw new UIWidgetsError(information);
});
_geometry = value;

public override Rect paintBounds {
get {
D.assert(constraints.axis != null);
switch (constraints.axis) {
case Axis.horizontal:
return Rect.fromLTWH(

geometry.paintExtent
);
}
// D.assert(false);
return null;
}
}

informationCollector: infoCollector);
});
D.assert(() => {
if (geometry.paintExtent > constraints.remainingPaintExtent) {
if (geometry.paintOrigin + geometry.paintExtent > constraints.remainingPaintExtent) {
"paintExtent", geometry.paintExtent));
"paintOrigin + paintExtent", geometry.paintOrigin + geometry.paintExtent));
throw new UIWidgetsError(
diagnosticInfo
);
throw new UIWidgetsError(diagnosticInfo);
}
return true;

get { return 0.0f; }
}
public virtual bool hitTest(SliverHitTestResult result, float mainAxisPosition = 0, float crossAxisPosition = 0) {
public virtual bool hitTest(SliverHitTestResult result, float mainAxisPosition = 0.0f, float crossAxisPosition = 0.0f) {
if (mainAxisPosition >= 0.0f && mainAxisPosition < geometry.hitTestExtent &&
crossAxisPosition >= 0.0f && crossAxisPosition < constraints.crossAxisExtent) {
if (hitTestChildren(result, mainAxisPosition: mainAxisPosition,

return false;
}
protected virtual bool hitTestSelf(float mainAxisPosition = 0, float crossAxisPosition = 0) {
protected virtual bool hitTestSelf(float mainAxisPosition = 0.0f, float crossAxisPosition = 0.0f) {
protected virtual bool hitTestChildren(SliverHitTestResult result, float mainAxisPosition = 0,
float crossAxisPosition = 0) {
protected virtual bool hitTestChildren(SliverHitTestResult result, float mainAxisPosition = 0.0f,
float crossAxisPosition = 0.0f) {
return false;
}

case AxisDirection.left:
return new Size(-geometry.paintExtent, constraints.crossAxisExtent);
}
//D.assert(false);
return null;
}

});
}
public override void handleEvent(PointerEvent evt, HitTestEntry entry) {
entry = (SliverHitTestEntry) entry;
}
public override void handleEvent(PointerEvent evt, HitTestEntry entry) { }
public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
base.debugFillProperties(properties);
properties.add(new DiagnosticsProperty<SliverGeometry>("geometry", geometry));

public static class RenderSliverHelpers {
public static bool _getRightWayUp(SliverConstraints constraints) {
D.assert(constraints != null);
bool rightWayUp = true;
switch (constraints.axisDirection) {

float? absoluteCrossAxisPosition = crossAxisPosition - crossAxisDelta;
Offset paintOffset = null;
Offset transformedPosition = null;
D.assert(it.constraints.axis != null);
switch (it.constraints.axis) {
case Axis.horizontal:
if (!rightWayUp) {

new Offset(-(geometry.scrollExtent - (geometry.paintExtent + constraints.scrollOffset)),
0.0f);
break;
D.assert(childParentData.paintOffset != null);
}
protected override bool hitTestChildren(SliverHitTestResult result, float mainAxisPosition = 0.0f,

return;
}
SliverConstraints constraints = this.constraints;
child.layout(constraints.asBoxConstraints(), parentUsesSize: true);
float childExtent = 0.0f;

95
com.unity.uiwidgets/Runtime/rendering/sliver_fill.cs


using UnityEngine;
namespace Unity.UIWidgets.rendering {
public class RenderSliverFillViewport : RenderSliverFixedExtentBoxAdaptor {
public RenderSliverFillViewport(
RenderSliverBoxChildManager childManager = null,
float viewportFraction = 1.0f
) :
base(childManager: childManager) {
D.assert(viewportFraction > 0.0);
_viewportFraction = viewportFraction;
}
public override float itemExtent {
get { return constraints.viewportMainAxisExtent * viewportFraction; }
set { }
}
float _viewportFraction;
public float viewportFraction {
get { return _viewportFraction; }
set {
if (_viewportFraction == value) {
return;
}
_viewportFraction = value;
markNeedsLayout();
}
}
}
class RenderSliverFillRemainingWithScrollable : RenderSliverSingleBoxAdapter {
public RenderSliverFillRemainingWithScrollable(RenderBox child = null) : base(child: child) {

setChildParentData(child, constraints, geometry);
}
}
public class RenderSliverFillViewport : RenderSliverFixedExtentBoxAdaptor {
public RenderSliverFillViewport(
RenderSliverBoxChildManager childManager = null,
float viewportFraction = 1.0f
) :
base(childManager: childManager) {
D.assert(viewportFraction > 0.0);
_viewportFraction = viewportFraction;
}
public override float itemExtent {
get { return constraints.viewportMainAxisExtent * viewportFraction; }
set { }
}
float _viewportFraction;
public float viewportFraction {
get { return _viewportFraction; }
set {
if (_viewportFraction == value) {
return;
}
_viewportFraction = value;
markNeedsLayout();
}
}
float _padding {
get { return (1.0f - viewportFraction) * constraints.viewportMainAxisExtent * 0.5f; }
}
protected override float indexToLayoutOffset(float itemExtent, int index) {
return _padding + base.indexToLayoutOffset(itemExtent, index);
}
protected override int getMinChildIndexForScrollOffset(float scrollOffset, float itemExtent) {
return base.getMinChildIndexForScrollOffset(Mathf.Max(scrollOffset - _padding, 0.0f), itemExtent);
}
protected override int getMaxChildIndexForScrollOffset(float scrollOffset, float itemExtent) {
return base.getMaxChildIndexForScrollOffset(Mathf.Max(scrollOffset - _padding, 0.0f), itemExtent);
}
protected override float estimateMaxScrollOffset(SliverConstraints constraints,
int firstIndex = 0,
int lastIndex = 0,
float leadingScrollOffset = 0.0f,
float trailingScrollOffset = 0.0f
) {
float padding = _padding;
return childManager.estimateMaxScrollOffset(
constraints,
firstIndex: firstIndex,
lastIndex: lastIndex,
leadingScrollOffset: leadingScrollOffset - padding,
trailingScrollOffset: trailingScrollOffset - padding
) + padding + padding;
}
}
public class RenderSliverFillRemainingAndOverscroll : RenderSliverSingleBoxAdapter {

setChildParentData(child, constraints, geometry);
}
}
}

95
com.unity.uiwidgets/Runtime/rendering/sliver_fixed_extent_list.cs


}
protected virtual int getMinChildIndexForScrollOffset(float scrollOffset, float itemExtent) {
return itemExtent > 0.0 ? Mathf.Max(0, (int) (scrollOffset / itemExtent)) : 0;
if (itemExtent > 0.0) {
float actual = scrollOffset / itemExtent;
int round = actual.round();
if ((actual - round).abs() < foundation_.precisionErrorTolerance) {
return round;
}
return actual.floor();
}
return 0;
}
protected virtual int getMaxChildIndexForScrollOffset(float scrollOffset, float itemExtent) {

protected virtual float estimateMaxScrollOffset(SliverConstraints constraints,
protected virtual float estimateMaxScrollOffset(
SliverConstraints constraints,
int firstIndex = 0,
int lastIndex = 0,
float leadingScrollOffset = 0.0f,

return childManager.childCount.Value * itemExtent;
}
int _calculateLeadingGarbage(int firstIndex) {
RenderBox walker = firstChild;
int leadingGarbage = 0;
while(walker != null && indexOf(walker) < firstIndex){
leadingGarbage += 1;
walker = childAfter(walker);
}
return leadingGarbage;
}
int _calculateTrailingGarbage(int targetLastIndex) {
RenderBox walker = lastChild;
int trailingGarbage = 0;
while(walker != null && indexOf(walker) > targetLastIndex){
trailingGarbage += 1;
walker = childBefore(walker);
}
return trailingGarbage;
}
SliverConstraints constraints = this.constraints;
childManager.didStartLayout();
childManager.setDidUnderflow(false);

: (int?) null;
if (firstChild != null) {
int oldFirstIndex = indexOf(firstChild);
int oldLastIndex = indexOf(lastChild);
int leadingGarbage = (firstIndex - oldFirstIndex).clamp(0, childCount);
int trailingGarbage =
targetLastIndex == null ? 0 : (oldLastIndex - targetLastIndex.Value).clamp(0, childCount);
int leadingGarbage = _calculateLeadingGarbage(firstIndex);
int trailingGarbage = targetLastIndex == null ? 0: _calculateTrailingGarbage(targetLastIndex.Value);
collectGarbage(leadingGarbage, trailingGarbage);
}
else {

if (firstChild == null) {
if (!addInitialChild(index: firstIndex,
layoutOffset: indexToLayoutOffset(itemExtent, firstIndex))) {
float max = computeMaxScrollOffset(constraints, itemExtent);
float max;
if (childManager.childCount != null) {
max = computeMaxScrollOffset(constraints, itemExtent);
}
else if (firstIndex <= 0) {
max = 0.0f;
}
else {
// We will have to find it manually.
int possibleFirstIndex = firstIndex - 1;
while (
possibleFirstIndex > 0 &&
!addInitialChild(
index: possibleFirstIndex,
layoutOffset: indexToLayoutOffset(itemExtent, possibleFirstIndex)
)
) {
possibleFirstIndex -= 1;
}
max = possibleFirstIndex * itemExtent;
}
geometry = new SliverGeometry(
scrollExtent: max,
maxPaintExtent: max

trailingChildWithLayout = firstChild;
}
while (targetLastIndex == null || indexOf(trailingChildWithLayout) < targetLastIndex) {
float estimatedMaxScrollOffset = float.PositiveInfinity;
for (int index = indexOf(trailingChildWithLayout) + 1;
targetLastIndex == null || index <= targetLastIndex;
++index) {
if (child == null) {
if (child == null || indexOf(child) != index) {
estimatedMaxScrollOffset = index * itemExtent;
break;
}
}

trailingChildWithLayout = child;
D.assert(child != null);
D.assert(childParentData.index == index);
childParentData.layoutOffset = indexToLayoutOffset(itemExtent, childParentData.index);
}

D.assert(firstIndex == 0 || childScrollOffset(firstChild) <= scrollOffset);
D.assert(firstIndex == 0 ||
childScrollOffset(firstChild) - scrollOffset <= foundation_.precisionErrorTolerance);
float estimatedMaxScrollOffset = estimateMaxScrollOffset(
constraints,
firstIndex: firstIndex,
lastIndex: lastIndex,
leadingScrollOffset: leadingScrollOffset,
trailingScrollOffset: trailingScrollOffset
estimatedMaxScrollOffset = Mathf.Min(
estimatedMaxScrollOffset,
estimateMaxScrollOffset(
constraints,
firstIndex: firstIndex,
lastIndex: lastIndex,
leadingScrollOffset: leadingScrollOffset,
trailingScrollOffset: trailingScrollOffset
)
);
float paintExtent = calculatePaintOffset(

40
com.unity.uiwidgets/Runtime/rendering/sliver_grid.cs


using System.Collections.Generic;
using Unity.UIWidgets.foundation;
using Unity.UIWidgets.painting;
using Unity.UIWidgets.rendering;

}
public override string ToString() {
return "SliverGridGeometry(" +
"scrollOffset: $scrollOffset, " +
"crossAxisOffset: $crossAxisOffset, " +
"mainAxisExtent: $mainAxisExtent, " +
"crossAxisExtent: $crossAxisExtent" +
")";
List<string> properties = new List<string>();
properties.Add("scrollOffset: $scrollOffset");
properties.Add("crossAxisOffset: $crossAxisOffset");
properties.Add("mainAxisExtent: $mainAxisExtent");
properties.Add("crossAxisExtent: $crossAxisExtent");
return $"SliverGridGeometry({string.Join(", ",properties)})";
}
}

float? childCrossAxisExtent = null,
bool? reverseCrossAxis = null
) {
D.assert(crossAxisCount != null && crossAxisCount > 0);
D.assert(mainAxisStride != null && mainAxisStride >= 0);
D.assert(crossAxisStride != null && crossAxisStride >= 0);
D.assert(childMainAxisExtent != null && childMainAxisExtent >= 0);
D.assert(childCrossAxisExtent != null && childCrossAxisExtent >= 0);
D.assert(crossAxisCount > 0);
D.assert(mainAxisStride >= 0);
D.assert(crossAxisStride >= 0);
D.assert(childMainAxisExtent >= 0);
D.assert(childCrossAxisExtent >= 0);
D.assert(reverseCrossAxis != null);
this.crossAxisCount = crossAxisCount;
this.mainAxisStride = mainAxisStride;

}
public abstract class SliverGridDelegate {
protected SliverGridDelegate() { }
public abstract SliverGridLayout getLayout(SliverConstraints constraints);
public abstract bool shouldRelayout(SliverGridDelegate oldDelegate);

public float crossAxisOffset;
public override string ToString() {
return "crossAxisOffset=$crossAxisOffset; ${base.ToString()}";
return $"crossAxisOffset={crossAxisOffset}; {base.ToString()}";
}
}

SliverGridGeometry gridGeometry = layout.getGeometryForChildIndex(index);
BoxConstraints childConstraints = gridGeometry.getBoxConstraints(constraints);
RenderBox child = childAfter(trailingChildWithLayout);
if (child == null) {
if (child == null || indexOf(child) != index) {
child = insertAndLayoutChild(childConstraints, after: trailingChildWithLayout);
if (child == null) {
break;

}
trailingChildWithLayout = child;
D.assert(child != null);
SliverGridParentData childParentData = child.parentData as SliverGridParentData;
childParentData.layoutOffset = gridGeometry.scrollOffset ?? 0.0f;
childParentData.crossAxisOffset = gridGeometry.crossAxisOffset ?? 0.0f;

D.assert(indexOf(firstChild) == firstIndex);
D.assert(targetLastIndex == null || lastIndex <= targetLastIndex);
float estimatedTotalExtent = childManager.estimateMaxScrollOffset(constraints,
float estimatedTotalExtent = childManager.estimateMaxScrollOffset(
constraints,
firstIndex: firstIndex,
lastIndex: lastIndex,
leadingScrollOffset: leadingScrollOffset ?? 0.0f,

float paintExtent = calculatePaintOffset(constraints,
float paintExtent = calculatePaintOffset(
constraints,
float cacheExtent = calculateCacheOffset(constraints,
float cacheExtent = calculateCacheOffset(
constraints,
from: leadingScrollOffset ?? 0.0f,
to: trailingScrollOffset ?? 0.0f
);

2
com.unity.uiwidgets/Runtime/rendering/sliver_list.cs


}
else {
float firstChildScrollOffset = earliestScrollOffset - paintExtentOf(firstChild);
if (firstChildScrollOffset < -SliverGeometry.precisionErrorTolerance) {
if (firstChildScrollOffset < -foundation_.precisionErrorTolerance) {
float correction = 0.0f;
while (earliestUsefulChild != null) {
D.assert(firstChild == earliestUsefulChild);

11
com.unity.uiwidgets/Runtime/rendering/sliver_multi_box_adaptor.cs


}
public bool keptAlive { get; }
}
}
public interface RenderSliverBoxChildManager {
void createChild(int index, RenderBox after = null);

public bool debugChildIntegrityEnabled {
get { return _debugChildIntegrityEnabled;}
set {
D.assert(value != null);
D.assert(() =>{
_debugChildIntegrityEnabled = value;
return _debugVerifyChildOrder() &&

childManager.didAdoptChild(child);
D.assert(()=> {
if (_keepAliveBucket.ContainsKey(childParentData.index))
_debugDanglingKeepAlives.Add(_keepAliveBucket[childParentData.index]);
_debugDanglingKeepAlives.Add(_keepAliveBucket.getOrDefault(childParentData.index));
return true;
});
_keepAliveBucket[childParentData.index] = child;

public int indexOf(RenderBox child) {
D.assert(child != null);
SliverMultiBoxAdaptorParentData childParentData = (SliverMultiBoxAdaptorParentData) child.parentData;
D.assert(childParentData.index != null);
return childParentData.index;
}

addExtent = true;
break;
}
D.assert(mainAxisUnit != null);
RenderBox child = firstChild;
while (child != null) {
float mainAxisDelta = childMainAxisPosition(child) ?? 0.0f;

public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
base.debugFillProperties(properties);
properties.add(DiagnosticsNode.message(firstChild != null
? "currently live children: " + indexOf(firstChild) + " to " + indexOf(lastChild)
: "no children current live"));
? $"currently live children: {indexOf(firstChild)} to {indexOf(lastChild)}" : "no children current live"));
}
public bool debugAssertChildListIsNonEmptyAndContiguous() {

11
com.unity.uiwidgets/Runtime/rendering/sliver_padding.cs


get {
D.assert(constraints != null);
D.assert(constraints.axisDirection != null);
D.assert(constraints.growthDirection != null);
D.assert(resolvedPadding != null);
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
case AxisDirection.up:

get {
D.assert(constraints != null);
D.assert(constraints.axisDirection != null);
D.assert(constraints.growthDirection != null);
D.assert(resolvedPadding != null);
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
case AxisDirection.up:

),
hasVisualOverflow: childLayoutGeometry.hasVisualOverflow
);
SliverPhysicalParentData childParentData = child.parentData as SliverPhysicalParentData;
D.assert(constraints.axisDirection != null);
D.assert(constraints.growthDirection != null);
SliverPhysicalParentData childParentData = child.parentData as SliverPhysicalParentData;
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
case AxisDirection.up:
childParentData.paintOffset = new Offset(resolvedPadding.left, calculatePaintOffset(constraints, from: resolvedPadding.bottom + childLayoutGeometry.scrollExtent, to: resolvedPadding.bottom + childLayoutGeometry.scrollExtent + resolvedPadding.top));

D.assert(child == this.child);
D.assert(constraints != null);
D.assert(constraints.axisDirection != null);
D.assert(constraints.growthDirection != null);
D.assert(resolvedPadding != null);
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
case AxisDirection.up:

get { return _padding; }
set {
D.assert(value != null);
D.assert(value.isNonNegative);
D.assert(padding.isNonNegative);
if (_padding == value) {
return;
}

if (_textDirection == value)
return;
_textDirection = value;
//_markNeedsResolution();
_markNeedsResolution();
}
}
TextDirection _textDirection;

83
com.unity.uiwidgets/Runtime/rendering/sliver_persistent_header.cs


using System;
using System.Collections.Generic;
using Unity.UIWidgets.animation;
using Unity.UIWidgets.foundation;
using Unity.UIWidgets.gestures;

float stretchTriggerOffset = 100.0f,
AsyncCallback onStretchTrigger = null
) {
D.assert(stretchTriggerOffset != null);
this.stretchTriggerOffset = stretchTriggerOffset;
this.onStretchTrigger = onStretchTrigger;
}

this.stretchConfiguration = stretchConfiguration;
}
float _lastStretchOffset;
public virtual float? maxExtent { get; }
public virtual float? minExtent { get; }

return true;
}
throw new UIWidgetsError(
"The maxExtent for this $runtimeType is less than its minExtent.\n" +
"The specified maxExtent was: ${maxExtent.toStringAsFixed(1)}\n" +
"The specified minExtent was: ${minExtent.toStringAsFixed(1)}\n"
);
throw new UIWidgetsError(new List<DiagnosticsNode>{
new ErrorSummary($"The maxExtent for this {GetType()} is less than its minExtent."),
new FloatProperty("The specified maxExtent was", maxExtent),
new FloatProperty("The specified minExtent was", minExtent),
});
float stretchOffset = 0.0f;
if (stretchConfiguration != null && childMainAxisPosition(child) == 0.0)
stretchOffset += constraints.overlap.abs();
this.constraints.asBoxConstraints(
maxExtent: Mathf.Max(minExtent ?? 0.0f, maxExtent - shrinkOffset)),
constraints.asBoxConstraints(
maxExtent: Mathf.Max(minExtent?? 0.0f, maxExtent - shrinkOffset) + stretchOffset
),
if (stretchConfiguration != null &&
stretchConfiguration.onStretchTrigger != null &&
stretchOffset >= stretchConfiguration.stretchTriggerOffset &&
_lastStretchOffset <= stretchConfiguration.stretchTriggerOffset) {
stretchConfiguration.onStretchTrigger();
}
_lastStretchOffset = stretchOffset;
}
public override float? childMainAxisPosition(RenderObject child) {

protected override bool hitTestChildren(SliverHitTestResult result, float mainAxisPosition, float crossAxisPosition) {
protected override bool hitTestChildren(SliverHitTestResult result, float mainAxisPosition = 0.0f, float crossAxisPosition = 0.0f) {
D.assert(geometry.hitTestExtent > 0.0f);
if (child != null) {
return RenderSliverHelpers.hitTestBoxChild(this, new BoxHitTestResult(result), child, mainAxisPosition: mainAxisPosition,

}
}
protected bool excludeFromSemanticsScrolling {
get { return _excludeFromSemanticsScrolling; }
set {
if (_excludeFromSemanticsScrolling == value) {
return;
}
_excludeFromSemanticsScrolling = value;
}
}
bool _excludeFromSemanticsScrolling = false;
public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
base.debugFillProperties(properties);
properties.add(FloatProperty.lazy("maxExtent", () => maxExtent));

maxPaintExtent: maxExtent ?? 0.0f,
hasVisualOverflow: true
);
_childPosition = Mathf.Min(0.0f, paintExtent ?? 0.0f - childExtent);
_childPosition = updateGeometry();
}
public override float? childMainAxisPosition(RenderObject child) {

) : base(child: child,
stretchConfiguration: stretchConfiguration) {
}
SliverConstraints constraints = this.constraints;
excludeFromSemanticsScrolling =
overlapsContent || (constraints.scrollOffset > maxExtent - minExtent);
float? layoutExtent =
(maxExtent - constraints.scrollOffset)?.clamp(0.0f, constraints.remainingPaintExtent);
float effectiveRemainingPaintExtent = Mathf.Max(0, constraints.remainingPaintExtent - constraints.overlap);
float? layoutExtent = (maxExtent - constraints.scrollOffset)?.clamp(0.0f, effectiveRemainingPaintExtent);
float stretchOffset = stretchConfiguration != null ?
constraints.overlap.abs() :
0.0f;
paintExtent: Mathf.Min(childExtent, constraints.remainingPaintExtent),
paintExtent: Mathf.Min(childExtent, effectiveRemainingPaintExtent),
maxPaintExtent: maxExtent ?? 0.0f,
maxPaintExtent: (maxExtent ?? 0.0f) + stretchOffset,
maxScrollObstructionExtent: minExtent ?? 0.0f,
cacheExtent: layoutExtent > 0.0f ? -constraints.cacheOrigin + layoutExtent : layoutExtent,
hasVisualOverflow: true

TimeSpan? duration = null
) {
D.assert(vsync != null);
D.assert(curve != null);
D.assert(duration != null);
this.vsync = vsync;
this.curve = curve ?? Curves.ease;
this.duration = duration ?? new TimeSpan(0, 0, 0, 0, 300);

FloatingHeaderSnapConfiguration _snapConfiguration;
protected virtual float updateGeometry() {
float stretchOffset = 0.0f;
if (stretchConfiguration != null && _childPosition == 0.0) {
stretchOffset += constraints.overlap.abs();
}
float? maxExtent = this.maxExtent;
float? paintExtent = maxExtent - _effectiveScrollOffset;
float? layoutExtent = maxExtent - constraints.scrollOffset;

paintExtent: paintExtent?.clamp(0.0f, constraints.remainingPaintExtent) ?? 0.0f,
layoutExtent: layoutExtent?.clamp(0.0f, constraints.remainingPaintExtent),
maxPaintExtent: maxExtent ?? 0.0f,
maxScrollObstructionExtent: maxExtent ?? 0.0f,
maxPaintExtent: (maxExtent ?? 0.0f) + stretchOffset,
return Mathf.Min(0.0f, paintExtent ?? 0.0f - childExtent);
return stretchOffset > 0 ? 0.0f : Mathf.Min(0.0f, paintExtent??0.0f - childExtent);
}
public void maybeStartSnapAnimation(ScrollDirection direction) {

}
protected override void performLayout() {
SliverConstraints constraints = this.constraints;
float? maxExtent = this.maxExtent;
if (((constraints.scrollOffset < _lastActualScrollOffset) ||
(_effectiveScrollOffset < maxExtent))) {

else {
_effectiveScrollOffset = constraints.scrollOffset;
}
excludeFromSemanticsScrolling = overlapsContent;
layoutChild(_effectiveScrollOffset, maxExtent ?? 0.0f, overlapsContent: overlapsContent);
layoutChild(
_effectiveScrollOffset,
maxExtent ?? 0.0f,
overlapsContent: overlapsContent
);
_childPosition = updateGeometry();
_lastActualScrollOffset = constraints.scrollOffset;
}

scrollExtent: maxExtent ?? 0.0f,
paintExtent: clampedPaintExtent ?? 0.0f,
layoutExtent: layoutExtent?.clamp(0.0f, clampedPaintExtent ?? 0.0f),
maxPaintExtent: maxExtent + stretchOffset ?? 0.0f,
maxPaintExtent: (maxExtent ?? 0.0f) + (stretchOffset ?? 0.0f),
maxScrollObstructionExtent: maxExtent ?? 0.0f,
hasVisualOverflow: true
);

62
com.unity.uiwidgets/Runtime/rendering/stack.cs


using Unity.UIWidgets.painting;
using Unity.UIWidgets.ui;
using UnityEngine;
using Debug = System.Diagnostics.Debug;
using Rect = Unity.UIWidgets.ui.Rect;
namespace Unity.UIWidgets.rendering {

public static bool operator !=(RelativeRect a, RelativeRect b) {
return !(a == b);
}
public override string ToString() {
return
$"RelativeRect.fromLTRB({left:F1}, {top :F1}, {right :F1}, {bottom :F1})";
}
}
public class StackParentData : ContainerParentDataMixinBoxParentData<RenderBox> {

left = value.left;
}
}
public override string ToString() {
List<string> values = new List<string>();
if (top != null) values.Add($"top={top:F1}");
if (right != null) values.Add($"right={right:F1}");
if (bottom != null) values.Add($"bottom=${bottom:F1}");
if (left != null) values.Add($"left=${left:F1}");
if (width != null) values.Add($"width=${width:F1}");
if (height != null) values.Add($"height=${height:F1}");
if (values.isEmpty())
values.Add("not positioned");
values.Add(base.ToString());
return string.Join("; ", values);
}
}
public enum StackFit {

public RenderStack(
List<RenderBox> children = null,
AlignmentGeometry alignment = null,
TextDirection? textDirection = null,
TextDirection textDirection = TextDirection.ltr,
StackFit fit = StackFit.loose,
Overflow overflow = Overflow.clip
) {

public AlignmentGeometry alignment {
get { return _alignment; }
set {
D.assert(value != null);
if (_alignment == value) {
return;
}

RenderBox child = firstChild;
while (child != null) {
StackParentData childParentData = child.parentData as StackParentData;
D.assert(childParentData != null);
if (!childParentData.isPositioned)
extent = Math.Max(extent, getter(child));
D.assert(child.parentData == childParentData);

public delegate float mainChildSizeGetter(RenderBox child);
float _getIntrinsicDimension(mainChildSizeGetter getter) {
float extent = 0.0f;
RenderBox child = firstChild;
while (child != null) {
StackParentData childParentData = (StackParentData) child.parentData;
if (!childParentData.isPositioned) {
extent = Mathf.Max(extent, getter(child));
}
D.assert(child.parentData == childParentData);
if (childParentData != null) {
child = childParentData.nextSibling;
}
}
return extent;
}
return _getIntrinsicDimension((RenderBox child) => child.getMinIntrinsicWidth(height));
return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMinIntrinsicWidth(height));
return _getIntrinsicDimension((RenderBox child) => child.getMaxIntrinsicWidth(height));
return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMaxIntrinsicWidth(height));
return _getIntrinsicDimension((RenderBox child) => child.getMinIntrinsicHeight(width));
return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMinIntrinsicHeight(width));
return _getIntrinsicDimension((RenderBox child) => child.getMaxIntrinsicHeight(width));
return getIntrinsicDimension(firstChild,(RenderBox child) => child.getMaxIntrinsicHeight(width));
}
protected override float? computeDistanceToActualBaseline(TextBaseline baseline) {

float height = constraints.minHeight;
BoxConstraints nonPositionedConstraints = null;
D.assert(fit != null);
switch (fit) {
case StackFit.loose:
nonPositionedConstraints = constraints.loosen();

RenderBox child = firstChild;
while (child != null) {
StackParentData childParentData = child.parentData as StackParentData;
D.assert(childParentData != null);
if (!childParentData.isPositioned) {
hasNonPositionedChildren = true;

public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
base.debugFillProperties(properties);
properties.add(new DiagnosticsProperty<AlignmentGeometry>("alignment", alignment));
properties.add(new EnumProperty<TextDirection>("textDirection", textDirection?? TextDirection.ltr));
properties.add(new EnumProperty<StackFit>("fit", fit));
properties.add(new EnumProperty<Overflow>("overflow", overflow));
}

) : base(
children: children,
alignment: alignment ?? AlignmentDirectional.topStart,
textDirection: textDirection) {
textDirection: textDirection?? TextDirection.ltr) {
_index = index;
}

int _index;
RenderBox _childAtIndex() {
D.assert(index != null);
RenderBox child = firstChild;
int i = 0;
while (child != null && i < index) {

return child;
}
protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
if (firstChild == null || index == null) {
protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
if (firstChild == null) {
return false;
}

}
public override void paintStack(PaintingContext context, Offset offset) {
if (firstChild == null || index == null) {
if (firstChild == null) {
return;
}

6
com.unity.uiwidgets/Runtime/widgets/editable_text.cs


public readonly StrutStyle strutStyle;
public readonly Color selectionColor;
public readonly float textScaleFactor;
public readonly TextAlign? textAlign;
public readonly TextAlign textAlign;
public readonly TextDirection? textDirection;
public readonly bool obscureText;
public readonly TextWidthBasis textWidthBasis;

StrutStyle strutStyle = null,
Color selectionColor = null,
float textScaleFactor = 1.0f,
TextAlign? textAlign = null,
TextAlign textAlign = TextAlign.start,
TextDirection? textDirection = null,
Locale locale = null,
bool obscureText = false,

strutStyle: strutStyle,
selectionColor: selectionColor,
textScaleFactor: textScaleFactor,
textAlign: textAlign ?? TextAlign.start,
textAlign: textAlign,
textDirection: textDirection,
locale: locale ?? Localizations.localeOf(context, nullOk: true),
selection: value.selection,

2
com.unity.uiwidgets/Runtime/widgets/widget_span.cs


class WidgetSpan : PlaceholderSpan,IEquatable<WidgetSpan> {
public WidgetSpan(
Widget child ,
TextBaseline? baseline = null,
TextBaseline baseline = TextBaseline.alphabetic,
TextStyle style = null,
PlaceholderAlignment alignment = PlaceholderAlignment.bottom
) : base(

正在加载...
取消
保存