您最多选择25个主题 主题必须以中文或者字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符
 
 
 
 
 
 

1456 行
50 KiB

using System;
using System.Collections.Generic;
using Unity.UIWidgets.animation;
using Unity.UIWidgets.foundation;
using Unity.UIWidgets.gestures;
using Unity.UIWidgets.painting;
using Unity.UIWidgets.ui;
using UnityEngine;
using Canvas = Unity.UIWidgets.ui.Canvas;
using Rect = Unity.UIWidgets.ui.Rect;
namespace Unity.UIWidgets.rendering {
public class ParentData {
public virtual void detach() {
}
public override string ToString() {
return "<none>";
}
}
public delegate void PaintingContextCallback(PaintingContext context, Offset offset);
public class PaintingContext : ClipContext {
PaintingContext(
ContainerLayer containerLayer = null,
Rect estimatedBounds = null
) {
D.assert(containerLayer != null);
D.assert(estimatedBounds != null);
this._containerLayer = containerLayer;
this.estimatedBounds = estimatedBounds;
}
readonly ContainerLayer _containerLayer;
public readonly Rect estimatedBounds;
public static void repaintCompositedChild(RenderObject child, bool debugAlsoPaintedParent = false) {
D.assert(child._needsPaint);
_repaintCompositedChild(
child,
debugAlsoPaintedParent: debugAlsoPaintedParent
);
}
static void _repaintCompositedChild(
RenderObject child,
bool debugAlsoPaintedParent = false,
PaintingContext childContext = null
) {
D.assert(child.isRepaintBoundary);
D.assert(() => {
child.debugRegisterRepaintBoundaryPaint(
includedParent: debugAlsoPaintedParent,
includedChild: true
);
return true;
});
if (child._layer == null) {
D.assert(debugAlsoPaintedParent);
child._layer = new OffsetLayer();
}
else {
D.assert(debugAlsoPaintedParent || child._layer.attached);
child._layer.removeAllChildren();
}
D.assert(() => {
child._layer.debugCreator = child.debugCreator ?? child.GetType().ToString();
return true;
});
childContext = childContext ?? new PaintingContext(child._layer, child.paintBounds);
child._paintWithContext(childContext, Offset.zero);
childContext.stopRecordingIfNeeded();
}
public static void debugInstrumentRepaintCompositedChild(
RenderObject child,
bool debugAlsoPaintedParent = false,
PaintingContext customContext = null
) {
D.assert(() => {
_repaintCompositedChild(
child,
debugAlsoPaintedParent: debugAlsoPaintedParent,
childContext: customContext
);
return true;
});
}
public void paintChild(RenderObject child, Offset offset) {
if (child.isRepaintBoundary) {
this.stopRecordingIfNeeded();
this._compositeChild(child, offset);
}
else {
child._paintWithContext(this, offset);
}
}
void _compositeChild(RenderObject child, Offset offset) {
D.assert(!this._isRecording);
D.assert(child.isRepaintBoundary);
D.assert(this._canvas == null || this._canvas.getSaveCount() == 1);
if (child._needsPaint) {
repaintCompositedChild(child, debugAlsoPaintedParent: true);
}
else {
D.assert(child._layer != null);
D.assert(() => {
child.debugRegisterRepaintBoundaryPaint(
includedParent: true,
includedChild: false
);
child._layer.debugCreator = child.debugCreator ?? child;
return true;
});
}
child._layer.offset = offset;
this.appendLayer(child._layer);
}
protected virtual void appendLayer(Layer layer) {
D.assert(!this._isRecording);
layer.remove();
this._containerLayer.append(layer);
}
bool _isRecording {
get {
bool hasCanvas = this._canvas != null;
D.assert(() => {
if (hasCanvas) {
D.assert(this._currentLayer != null);
D.assert(this._recorder != null);
D.assert(this._canvas != null);
}
else {
D.assert(this._currentLayer == null);
D.assert(this._recorder == null);
D.assert(this._canvas == null);
}
return true;
});
return hasCanvas;
}
}
PictureLayer _currentLayer;
PictureRecorder _recorder;
Canvas _canvas;
public override Canvas canvas {
get {
if (this._canvas == null) {
this._startRecording();
}
return this._canvas;
}
}
void _startRecording() {
D.assert(!this._isRecording);
this._currentLayer = new PictureLayer(this.estimatedBounds);
this._recorder = new PictureRecorder();
this._canvas = new RecorderCanvas(this._recorder);
this._containerLayer.append(this._currentLayer);
}
protected virtual void stopRecordingIfNeeded() {
if (!this._isRecording) {
return;
}
D.assert(() => {
if (D.debugRepaintRainbowEnabled) {
var paint = new Paint {
style = PaintingStyle.stroke,
strokeWidth = 6.0f,
color = D.debugCurrentRepaintColor.toColor()
};
this.canvas.drawRect(this.estimatedBounds.deflate(3.0f), paint);
}
if (D.debugPaintLayerBordersEnabled) {
Paint paint = new Paint {
style = PaintingStyle.stroke,
strokeWidth = 1.0f,
color = new ui.Color(0xFFFF9800),
};
this.canvas.drawRect(this.estimatedBounds, paint);
}
return true;
});
this._currentLayer.picture = this._recorder.endRecording();
this._currentLayer = null;
this._recorder = null;
this._canvas = null;
}
public void setIsComplexHint() {
if (this._currentLayer != null) {
this._currentLayer.isComplexHint = true;
}
}
public void setWillChangeHint() {
if (this._currentLayer != null) {
this._currentLayer.willChangeHint = true;
}
}
public void addLayer(Layer layer) {
this.stopRecordingIfNeeded();
this.appendLayer(layer);
}
public void pushLayer(ContainerLayer childLayer, PaintingContextCallback painter, Offset offset,
Rect childPaintBounds = null) {
D.assert(!childLayer.attached);
D.assert(childLayer.parent == null);
D.assert(painter != null);
this.stopRecordingIfNeeded();
this.appendLayer(childLayer);
var childContext = this.createChildContext(childLayer, childPaintBounds ?? this.estimatedBounds);
painter(childContext, offset);
childContext.stopRecordingIfNeeded();
}
protected PaintingContext createChildContext(ContainerLayer childLayer, Rect bounds) {
return new PaintingContext(childLayer, bounds);
}
public void pushClipRect(bool needsCompositing, Offset offset, Rect clipRect, PaintingContextCallback painter,
Clip clipBehavior = Clip.hardEdge) {
Rect offsetClipRect = clipRect.shift(offset);
if (needsCompositing) {
this.pushLayer(new ClipRectLayer(offsetClipRect, clipBehavior: clipBehavior),
painter, offset, childPaintBounds: offsetClipRect);
}
else {
this.clipRectAndPaint(offsetClipRect, clipBehavior, offsetClipRect, () => painter(this, offset));
}
}
public void pushClipRRect(bool needsCompositing, Offset offset, Rect bounds, RRect clipRRect,
PaintingContextCallback painter, Clip clipBehavior = Clip.antiAlias) {
Rect offsetBounds = bounds.shift(offset);
RRect offsetClipRRect = clipRRect.shift(offset);
if (needsCompositing) {
this.pushLayer(new ClipRRectLayer(offsetClipRRect, clipBehavior: clipBehavior),
painter, offset, childPaintBounds: offsetBounds);
}
else {
this.clipRRectAndPaint(offsetClipRRect, clipBehavior, offsetBounds, () => painter(this, offset));
}
}
public void pushClipPath(bool needsCompositing, Offset offset, Rect bounds, Path clipPath,
PaintingContextCallback painter, Clip clipBehavior = Clip.antiAlias) {
Rect offsetBounds = bounds.shift(offset);
Path offsetClipPath = clipPath.shift(offset);
if (needsCompositing) {
this.pushLayer(new ClipPathLayer(clipPath: offsetClipPath, clipBehavior: clipBehavior), painter, offset,
childPaintBounds: offsetBounds);
}
else {
this.clipPathAndPaint(offsetClipPath, clipBehavior, offsetBounds, () => painter(this, offset));
}
}
public void pushTransform(bool needsCompositing, Offset offset, Matrix3 transform,
PaintingContextCallback painter) {
Matrix3 effectiveTransform;
if (offset == null || offset == Offset.zero) {
effectiveTransform = transform;
} else {
effectiveTransform = Matrix3.makeTrans(offset.dx, offset.dy);
effectiveTransform.preConcat(transform);
effectiveTransform.preTranslate(-offset.dx, -offset.dy);
}
if (needsCompositing) {
var inverse = Matrix3.I();
var invertible = effectiveTransform.invert(inverse);
D.assert(invertible);
this.pushLayer(
new TransformLayer(effectiveTransform),
painter,
offset,
childPaintBounds: inverse.mapRect(this.estimatedBounds)
);
}
else {
this.canvas.save();
this.canvas.concat(effectiveTransform);
painter(this, offset);
this.canvas.restore();
}
}
public void pushOpacity(Offset offset, int alpha, PaintingContextCallback painter) {
this.pushLayer(new OpacityLayer(alpha: alpha), painter, offset);
}
public override string ToString() {
return
$"{this.GetType()}#{this.GetHashCode()}(layer: {this._containerLayer}, canvas bounds: {this.estimatedBounds}";
}
}
public abstract class Constraints {
public abstract bool isTight { get; }
public abstract bool isNormalized { get; }
public virtual bool debugAssertIsValid(
bool isAppliedConstraint = false,
InformationCollector informationCollector = null
) {
D.assert(this.isNormalized);
return this.isNormalized;
}
}
public delegate void RenderObjectVisitor(RenderObject child);
public delegate void LayoutCallback<T>(T constraints) where T : Constraints;
public class PipelineOwner {
public PipelineOwner(
VoidCallback onNeedVisualUpdate = null) {
this.onNeedVisualUpdate = onNeedVisualUpdate;
}
public readonly VoidCallback onNeedVisualUpdate;
public void requestVisualUpdate() {
if (this.onNeedVisualUpdate != null) {
this.onNeedVisualUpdate();
}
}
public AbstractNodeMixinDiagnosticableTree rootNode {
get { return this._rootNode; }
set {
if (this._rootNode == value) {
return;
}
if (this._rootNode != null) {
this._rootNode.detach();
}
this._rootNode = value;
if (this._rootNode != null) {
this._rootNode.attach(this);
}
}
}
AbstractNodeMixinDiagnosticableTree _rootNode;
internal List<RenderObject> _nodesNeedingLayout = new List<RenderObject>();
public bool debugDoingLayout {
get { return this._debugDoingLayout; }
}
internal bool _debugDoingLayout = false;
public void flushLayout() {
D.assert(() => {
this._debugDoingLayout = true;
return true;
});
try {
while (this._nodesNeedingLayout.isNotEmpty()) {
var dirtyNodes = this._nodesNeedingLayout;
this._nodesNeedingLayout = new List<RenderObject>();
dirtyNodes.Sort((a, b) => a.depth - b.depth);
foreach (var node in dirtyNodes) {
if (node._needsLayout && node.owner == this) {
node._layoutWithoutResize();
}
}
}
}
finally {
D.assert(() => {
this._debugDoingLayout = false;
return true;
});
}
}
internal bool _debugAllowMutationsToDirtySubtrees = false;
internal void _enableMutationsToDirtySubtrees(VoidCallback callback) {
D.assert(this._debugDoingLayout);
bool oldState = false;
D.assert(() => {
oldState = this._debugAllowMutationsToDirtySubtrees;
this._debugAllowMutationsToDirtySubtrees = true;
return true;
});
try {
callback();
}
finally {
D.assert(() => {
this._debugAllowMutationsToDirtySubtrees = oldState;
return true;
});
}
}
internal List<RenderObject> _nodesNeedingCompositingBitsUpdate = new List<RenderObject>();
public void flushCompositingBits() {
this._nodesNeedingCompositingBitsUpdate.Sort((a, b) => a.depth - b.depth);
foreach (RenderObject node in this._nodesNeedingCompositingBitsUpdate) {
if (node._needsCompositingBitsUpdate && node.owner == this) {
node._updateCompositingBits();
}
}
this._nodesNeedingCompositingBitsUpdate.Clear();
}
internal List<RenderObject> _nodesNeedingPaint = new List<RenderObject>();
public bool debugDoingPaint {
get { return this._debugDoingPaint; }
}
internal bool _debugDoingPaint = false;
public void flushPaint() {
D.assert(() => {
this._debugDoingPaint = true;
return true;
});
try {
var dirtyNodes = this._nodesNeedingPaint;
this._nodesNeedingPaint = new List<RenderObject>();
dirtyNodes.Sort((a, b) => a.depth - b.depth);
foreach (var node in dirtyNodes) {
D.assert(node._layer != null);
if (node._needsPaint && node.owner == this) {
if (node._layer.attached) {
PaintingContext.repaintCompositedChild(node);
}
else {
node._skippedPaintingOnLayer();
}
}
}
}
finally {
D.assert(() => {
this._debugDoingPaint = false;
return true;
});
}
}
}
public abstract class RenderObject : AbstractNodeMixinDiagnosticableTree, HitTestTarget {
protected RenderObject() {
this._needsCompositing = this.isRepaintBoundary || this.alwaysNeedsCompositing;
}
public ParentData parentData;
public virtual void setupParentData(RenderObject child) {
D.assert(this._debugCanPerformMutations);
if (!(child.parentData is ParentData)) {
child.parentData = new ParentData();
}
}
protected override void adoptChild(AbstractNodeMixinDiagnosticableTree childNode) {
var child = (RenderObject) childNode;
D.assert(this._debugCanPerformMutations);
D.assert(child != null);
this.setupParentData(child);
base.adoptChild(child);
this.markNeedsLayout();
this.markNeedsCompositingBitsUpdate();
}
protected override void dropChild(AbstractNodeMixinDiagnosticableTree childNode) {
var child = (RenderObject) childNode;
D.assert(this._debugCanPerformMutations);
D.assert(child != null);
D.assert(child.parentData != null);
child._cleanRelayoutBoundary();
child.parentData.detach();
child.parentData = null;
base.dropChild(child);
this.markNeedsLayout();
this.markNeedsCompositingBitsUpdate();
}
public virtual void visitChildren(RenderObjectVisitor visitor) {
}
public object debugCreator;
void _debugReportException(string method, Exception exception) {
UIWidgetsError.reportError(new UIWidgetsErrorDetailsForRendering(
exception: exception,
library: "rendering library",
context: "during " + method,
renderObject: this,
informationCollector: information => {
information.AppendLine(
"The following RenderObject was being processed when the exception was fired:");
information.AppendLine(" " + this.toStringShallow(joiner: "\n "));
var descendants = new List<string>();
const int maxDepth = 5;
int depth = 0;
const int maxLines = 25;
int lines = 0;
RenderObjectVisitor visitor = null;
visitor = new RenderObjectVisitor((RenderObject child) => {
if (lines < maxLines) {
depth += 1;
descendants.Add(new string(' ', 2 * depth) + child);
if (depth < maxDepth) {
child.visitChildren(visitor);
}
depth -= 1;
}
else if (lines == maxLines) {
descendants.Add(" ...(descendants list truncated after " + lines + " lines)");
}
lines += 1;
});
this.visitChildren(visitor);
if (lines > 1) {
information.AppendLine(
"This RenderObject had the following descendants (showing up to depth " +
maxDepth + "):");
}
else if (descendants.Count == 1) {
information.AppendLine("This RenderObject had the following child:");
}
else {
information.AppendLine("This RenderObject has no descendants.");
}
information.Append(string.Join("\n", descendants.ToArray()));
}
));
}
public bool debugDoingThisResize {
get { return this._debugDoingThisResize; }
}
bool _debugDoingThisResize = false;
public bool debugDoingThisLayout {
get { return this._debugDoingThisLayout; }
}
bool _debugDoingThisLayout = false;
public static RenderObject debugActiveLayout {
get { return _debugActiveLayout; }
}
static RenderObject _debugActiveLayout;
public bool debugCanParentUseSize {
get { return this._debugCanParentUseSize; }
}
bool _debugCanParentUseSize;
bool _debugMutationsLocked = false;
bool _debugCanPerformMutations {
get {
bool result = true;
D.assert(() => {
RenderObject node = this;
while (true) {
if (node._doingThisLayoutWithCallback) {
result = true;
break;
}
if (this.owner != null && this.owner._debugAllowMutationsToDirtySubtrees && node._needsLayout) {
result = true;
break;
}
if (node._debugMutationsLocked) {
result = false;
break;
}
if (!(node.parent is RenderObject)) {
result = true;
break;
}
node = (RenderObject) node.parent;
}
return true;
});
return result;
}
}
public new PipelineOwner owner {
get { return (PipelineOwner) base.owner; }
}
public override void attach(object ownerObject) {
var owner = (PipelineOwner) ownerObject;
base.attach(owner);
if (this._needsLayout && this._relayoutBoundary != null) {
this._needsLayout = false;
this.markNeedsLayout();
}
if (this._needsCompositingBitsUpdate) {
this._needsCompositingBitsUpdate = false;
this.markNeedsCompositingBitsUpdate();
}
if (this._needsPaint && this._layer != null) {
this._needsPaint = false;
this.markNeedsPaint();
}
}
public bool debugNeedsLayout {
get {
bool result = false;
D.assert(() => {
result = this._needsLayout;
return true;
});
return result;
}
}
internal bool _needsLayout = true;
public RenderObject _relayoutBoundary;
bool _doingThisLayoutWithCallback = false;
public Constraints constraints {
get { return this._constraints; }
}
Constraints _constraints;
protected abstract void debugAssertDoesMeetConstraints();
internal static bool debugCheckingIntrinsics = false;
bool _debugSubtreeRelayoutRootAlreadyMarkedNeedsLayout() {
if (this._relayoutBoundary == null) {
return true;
}
RenderObject node = this;
while (node != this._relayoutBoundary) {
D.assert(node._relayoutBoundary == this._relayoutBoundary);
D.assert(node.parent != null);
node = (RenderObject) node.parent;
if ((!node._needsLayout) && (!node._debugDoingThisLayout)) {
return false;
}
}
D.assert(node._relayoutBoundary == node);
return true;
}
public virtual void markNeedsLayout() {
D.assert(this._debugCanPerformMutations);
if (this._needsLayout) {
D.assert(this._debugSubtreeRelayoutRootAlreadyMarkedNeedsLayout());
return;
}
D.assert(this._relayoutBoundary != null);
if (this._relayoutBoundary != this) {
this.markParentNeedsLayout();
}
else {
this._needsLayout = true;
if (this.owner != null) {
D.assert(() => {
if (D.debugPrintMarkNeedsLayoutStacks) {
Debug.Log("markNeedsLayout() called for " + this);
}
return true;
});
this.owner._nodesNeedingLayout.Add(this);
this.owner.requestVisualUpdate();
}
}
}
protected void markParentNeedsLayout() {
this._needsLayout = true;
RenderObject parent = (RenderObject) this.parent;
if (!this._doingThisLayoutWithCallback) {
parent.markNeedsLayout();
}
else {
D.assert(parent._debugDoingThisLayout);
}
}
public void markNeedsLayoutForSizedByParentChange() {
this.markNeedsLayout();
this.markParentNeedsLayout();
}
void _cleanRelayoutBoundary() {
if (this._relayoutBoundary != this) {
this._relayoutBoundary = null;
this._needsLayout = true;
this.visitChildren(child => { child._cleanRelayoutBoundary(); });
}
}
public void scheduleInitialLayout() {
D.assert(this.attached);
D.assert(!(this.parent is RenderObject));
D.assert(!this.owner._debugDoingLayout);
D.assert(this._relayoutBoundary == null);
this._relayoutBoundary = this;
D.assert(() => {
this._debugCanParentUseSize = false;
return true;
});
this.owner._nodesNeedingLayout.Add(this);
}
internal void _layoutWithoutResize() {
D.assert(this._relayoutBoundary == this);
RenderObject debugPreviousActiveLayout = null;
D.assert(!this._debugMutationsLocked);
D.assert(!this._doingThisLayoutWithCallback);
D.assert(() => {
this._debugMutationsLocked = true;
this._debugDoingThisLayout = true;
debugPreviousActiveLayout = _debugActiveLayout;
_debugActiveLayout = this;
if (D.debugPrintLayouts) {
Debug.Log("Laying out (without resize) " + this);
}
return true;
});
try {
this.performLayout();
}
catch (Exception ex) {
this._debugReportException("performLayout", ex);
}
D.assert(() => {
_debugActiveLayout = debugPreviousActiveLayout;
this._debugDoingThisLayout = false;
this._debugMutationsLocked = false;
return true;
});
this._needsLayout = false;
this.markNeedsPaint();
}
public void layout(Constraints constraints, bool parentUsesSize = false) {
D.assert(constraints != null);
D.assert(constraints.debugAssertIsValid(
isAppliedConstraint: true,
informationCollector: information => {
// final List<String> stack = StackTrace.current.toString().split('\n');
// int targetFrame;
// final Pattern layoutFramePattern = RegExp(r'^#[0-9]+ +RenderObject.layout \(');
// for (int i = 0; i < stack.length; i += 1) {
// if (layoutFramePattern.matchAsPrefix(stack[i]) != null) {
// targetFrame = i + 1;
// break;
// }
// }
// if (targetFrame != null && targetFrame < stack.length) {
// information.writeln(
// 'These invalid constraints were provided to $runtimeType\'s layout() '
// 'function by the following function, which probably computed the '
// 'invalid constraints in question:'
// );
// final Pattern targetFramePattern = RegExp(r'^#[0-9]+ +(.+)$');
// final Match targetFrameMatch = targetFramePattern.matchAsPrefix(stack[targetFrame]);
// if (targetFrameMatch != null && targetFrameMatch.groupCount > 0) {
// information.writeln(' ${targetFrameMatch.group(1)}');
// } else {
// information.writeln(stack[targetFrame]);
// }
// }
}));
D.assert(!this._debugDoingThisResize);
D.assert(!this._debugDoingThisLayout);
RenderObject relayoutBoundary;
if (!parentUsesSize || this.sizedByParent || constraints.isTight || !(this.parent is RenderObject)) {
relayoutBoundary = this;
}
else {
RenderObject parent = (RenderObject) this.parent;
relayoutBoundary = parent._relayoutBoundary;
}
D.assert(() => {
this._debugCanParentUseSize = parentUsesSize;
return true;
});
if (!this._needsLayout && Equals(constraints, this._constraints) &&
relayoutBoundary == this._relayoutBoundary) {
D.assert(() => {
this._debugDoingThisResize = this.sizedByParent;
this._debugDoingThisLayout = !this.sizedByParent;
RenderObject debugPreviousActiveLayout1 = _debugActiveLayout;
_debugActiveLayout = this;
this.debugResetSize();
_debugActiveLayout = debugPreviousActiveLayout1;
this._debugDoingThisLayout = false;
this._debugDoingThisResize = false;
return true;
});
return;
}
this._constraints = constraints;
this._relayoutBoundary = relayoutBoundary;
D.assert(!this._debugMutationsLocked);
D.assert(!this._doingThisLayoutWithCallback);
D.assert(() => {
this._debugMutationsLocked = true;
if (D.debugPrintLayouts) {
Debug.Log("Laying out (" + (this.sizedByParent ? "with separate resize" : "with resize allowed") +
") " + this);
}
return true;
});
if (this.sizedByParent) {
D.assert(() => {
this._debugDoingThisResize = true;
return true;
});
try {
this.performResize();
D.assert(() => {
this.debugAssertDoesMeetConstraints();
return true;
});
}
catch (Exception ex) {
this._debugReportException("performResize", ex);
}
D.assert(() => {
this._debugDoingThisResize = false;
return true;
});
}
RenderObject debugPreviousActiveLayout = null;
D.assert(() => {
this._debugDoingThisLayout = true;
debugPreviousActiveLayout = _debugActiveLayout;
_debugActiveLayout = this;
return true;
});
try {
this.performLayout();
D.assert(() => {
this.debugAssertDoesMeetConstraints();
return true;
});
}
catch (Exception ex) {
this._debugReportException("performLayout", ex);
}
D.assert(() => {
_debugActiveLayout = debugPreviousActiveLayout;
this._debugDoingThisLayout = false;
this._debugMutationsLocked = false;
return true;
});
this._needsLayout = false;
this.markNeedsPaint();
}
protected virtual void debugResetSize() {
}
protected virtual bool sizedByParent {
get { return false; }
}
protected abstract void performResize();
protected abstract void performLayout();
protected void invokeLayoutCallback<T>(LayoutCallback<T> callback) where T : Constraints {
D.assert(this._debugMutationsLocked);
D.assert(this._debugDoingThisLayout);
D.assert(!this._doingThisLayoutWithCallback);
this._doingThisLayoutWithCallback = true;
try {
this.owner._enableMutationsToDirtySubtrees(() => { callback((T) this.constraints); });
}
finally {
this._doingThisLayoutWithCallback = false;
}
}
public bool debugDoingThisPaint {
get { return this._debugDoingThisPaint; }
}
bool _debugDoingThisPaint = false;
public static RenderObject debugActivePaint {
get { return _debugActivePaint; }
}
static RenderObject _debugActivePaint;
public virtual bool isRepaintBoundary {
get { return false; }
}
public virtual void debugRegisterRepaintBoundaryPaint(bool includedParent = true, bool includedChild = false) {
}
protected virtual bool alwaysNeedsCompositing {
get { return false; }
}
internal OffsetLayer _layer;
public OffsetLayer layer {
get {
D.assert(this.isRepaintBoundary,
"You can only access RenderObject.layer for render objects that are repaint boundaries.");
D.assert(!this._needsPaint);
return this._layer;
}
}
public OffsetLayer debugLayer {
get {
OffsetLayer result = null;
D.assert(() => {
result = this._layer;
return true;
});
return result;
}
}
internal bool _needsCompositingBitsUpdate = false;
public void markNeedsCompositingBitsUpdate() {
if (this._needsCompositingBitsUpdate) {
return;
}
this._needsCompositingBitsUpdate = true;
if (this.parent is RenderObject) {
var parent = (RenderObject) this.parent;
if (parent._needsCompositingBitsUpdate) {
return;
}
if (!this.isRepaintBoundary && !parent.isRepaintBoundary) {
parent.markNeedsCompositingBitsUpdate();
return;
}
}
D.assert(() => {
var parent = this.parent;
if (parent is RenderObject) {
return ((RenderObject) parent)._needsCompositing;
}
return true;
});
if (this.owner != null) {
this.owner._nodesNeedingCompositingBitsUpdate.Add(this);
}
}
bool _needsCompositing;
public bool needsCompositing {
get {
D.assert(!this._needsCompositingBitsUpdate);
return this._needsCompositing;
}
}
public void _updateCompositingBits() {
if (!this._needsCompositingBitsUpdate) {
return;
}
bool oldNeedsCompositing = this._needsCompositing;
this._needsCompositing = false;
this.visitChildren(child => {
child._updateCompositingBits();
if (child.needsCompositing) {
this._needsCompositing = true;
}
});
if (this.isRepaintBoundary || this.alwaysNeedsCompositing) {
this._needsCompositing = true;
}
if (oldNeedsCompositing != this._needsCompositing) {
this.markNeedsPaint();
}
this._needsCompositingBitsUpdate = false;
}
bool debugNeedsPaint {
get {
bool result = false;
D.assert(() => {
result = this._needsPaint;
return true;
});
return result;
}
}
internal bool _needsPaint = true;
public void markNeedsPaint() {
D.assert(this.owner == null || !this.owner.debugDoingPaint);
if (this._needsPaint) {
return;
}
this._needsPaint = true;
if (this.isRepaintBoundary) {
D.assert(() => {
if (D.debugPrintMarkNeedsPaintStacks) {
Debug.Log("markNeedsPaint() called for " + this);
}
return true;
});
D.assert(this._layer != null);
if (this.owner != null) {
this.owner._nodesNeedingPaint.Add(this);
this.owner.requestVisualUpdate();
}
}
else if (this.parent is RenderObject) {
D.assert(this._layer == null);
var parent = (RenderObject) this.parent;
parent.markNeedsPaint();
}
else {
D.assert(() => {
if (D.debugPrintMarkNeedsPaintStacks) {
Debug.Log("markNeedsPaint() called for " + this + " (root of render tree)");
}
return true;
});
if (this.owner != null) {
this.owner.requestVisualUpdate();
}
}
}
internal void _skippedPaintingOnLayer() {
D.assert(this.attached);
D.assert(this.isRepaintBoundary);
D.assert(this._needsPaint);
D.assert(this._layer != null);
D.assert(!this._layer.attached);
var ancestor = this.parent;
while (ancestor is RenderObject) {
var node = (RenderObject) ancestor;
if (node.isRepaintBoundary) {
if (node._layer == null) {
break;
}
if (node._layer.attached) {
break;
}
node._needsPaint = true;
}
ancestor = ancestor.parent;
}
}
public void scheduleInitialPaint(ContainerLayer rootLayer) {
D.assert(rootLayer.attached);
D.assert(this.attached);
D.assert(!(this.parent is RenderObject));
D.assert(!this.owner._debugDoingPaint);
D.assert(this.isRepaintBoundary);
D.assert(this._layer == null);
this._layer = (OffsetLayer) rootLayer;
D.assert(this._needsPaint);
this.owner._nodesNeedingPaint.Add(this);
}
public void replaceRootLayer(OffsetLayer rootLayer) {
D.assert(rootLayer.attached);
D.assert(this.attached);
D.assert(!(this.parent is RenderObject));
D.assert(!this.owner._debugDoingPaint);
D.assert(this.isRepaintBoundary);
D.assert(this._layer != null);
this._layer.detach();
this._layer = rootLayer;
this.markNeedsPaint();
}
internal void _paintWithContext(PaintingContext context, Offset offset) {
D.assert(() => {
if (this._debugDoingThisPaint) {
throw new UIWidgetsError(
"Tried to paint a RenderObject reentrantly.\n" +
"The following RenderObject was already being painted when it was " +
"painted again:\n" +
" " + this.toStringShallow(joiner: "\n ") + "\n" +
"Since this typically indicates an infinite recursion, it is " +
"disallowed."
);
}
return true;
});
if (this._needsLayout) {
return;
}
D.assert(() => {
if (this._needsCompositingBitsUpdate) {
throw new UIWidgetsError(
"Tried to paint a RenderObject before its compositing bits were " +
"updated.\n" +
"The following RenderObject was marked as having dirty compositing " +
"bits at the time that it was painted:\n" +
" " + this.toStringShallow(joiner: "\n ") + "\n" +
"A RenderObject that still has dirty compositing bits cannot be " +
"painted because this indicates that the tree has not yet been " +
"properly configured for creating the layer tree.\n" +
"This usually indicates an error in the Flutter framework itself."
);
}
return true;
});
RenderObject debugLastActivePaint = null;
D.assert(() => {
this._debugDoingThisPaint = true;
debugLastActivePaint = _debugActivePaint;
_debugActivePaint = this;
D.assert(!this.isRepaintBoundary || this._layer != null);
return true;
});
this._needsPaint = false;
try {
this.paint(context, offset);
D.assert(!this._needsLayout);
D.assert(!this._needsPaint);
}
catch (Exception ex) {
this._debugReportException("paint", ex);
}
D.assert(() => {
this.debugPaint(context, offset);
_debugActivePaint = debugLastActivePaint;
this._debugDoingThisPaint = false;
return true;
});
}
public abstract Rect paintBounds { get; }
public virtual void debugPaint(PaintingContext context, Offset offset) {
}
public virtual void paint(PaintingContext context, Offset offset) {
}
public virtual void applyPaintTransform(RenderObject child, Matrix3 transform) {
D.assert(child.parent == this);
}
public Matrix3 getTransformTo(RenderObject ancestor) {
D.assert(this.attached);
if (ancestor == null) {
var rootNode = this.owner.rootNode;
if (rootNode is RenderObject) {
ancestor = (RenderObject) rootNode;
}
}
var renderers = new List<RenderObject>();
for (RenderObject renderer = this; renderer != ancestor; renderer = (RenderObject) renderer.parent) {
D.assert(renderer != null);
renderers.Add(renderer);
}
var transform = Matrix3.I();
for (int index = renderers.Count - 1; index > 0; index -= 1) {
renderers[index].applyPaintTransform(renderers[index - 1], transform);
}
return transform;
}
public virtual Rect describeApproximatePaintClip(RenderObject child) {
return null;
}
public abstract Rect semanticBounds { get; }
public virtual void handleEvent(PointerEvent evt, HitTestEntry entry) {
}
public override string toStringShort() {
string header = Diagnostics.describeIdentity(this);
if (this._relayoutBoundary != null && this._relayoutBoundary != this) {
int count = 1;
RenderObject target = (RenderObject) this.parent;
while (target != null && target != this._relayoutBoundary) {
target = (RenderObject) target.parent;
count += 1;
}
header += " relayoutBoundary=up" + count;
}
if (this._needsLayout) {
header += " NEEDS-LAYOUT";
}
if (this._needsPaint) {
header += " NEEDS-PAINT";
}
if (!this.attached) {
header += " DETACHED";
}
return header;
}
public override string toString(DiagnosticLevel minLevel = DiagnosticLevel.debug) {
return this.toStringShort();
}
public override string toStringDeep(
string prefixLineOne = "",
string prefixOtherLines = "",
DiagnosticLevel minLevel = DiagnosticLevel.debug
) {
RenderObject debugPreviousActiveLayout = null;
D.assert(() => {
debugPreviousActiveLayout = _debugActiveLayout;
_debugActiveLayout = null;
return true;
});
string result = base.toStringDeep(
prefixLineOne: prefixLineOne,
prefixOtherLines: prefixOtherLines,
minLevel: minLevel
);
D.assert(() => {
_debugActiveLayout = debugPreviousActiveLayout;
return true;
});
return result;
}
public override string toStringShallow(
string joiner = ", ",
DiagnosticLevel minLevel = DiagnosticLevel.debug
) {
RenderObject debugPreviousActiveLayout = null;
D.assert(() => {
debugPreviousActiveLayout = _debugActiveLayout;
_debugActiveLayout = null;
return true;
});
string result = base.toStringShallow(joiner: joiner, minLevel: minLevel);
D.assert(() => {
_debugActiveLayout = debugPreviousActiveLayout;
return true;
});
return result;
}
public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
properties.add(new DiagnosticsProperty<object>(
"creator", this.debugCreator, defaultValue: Diagnostics.kNullDefaultValue,
level: DiagnosticLevel.debug));
properties.add(new DiagnosticsProperty<ParentData>("parentData", this.parentData,
tooltip: this._debugCanParentUseSize ? "can use size" : null, missingIfNull: true));
properties.add(new DiagnosticsProperty<Constraints>("constraints", this.constraints, missingIfNull: true));
properties.add(new DiagnosticsProperty<OffsetLayer>("layer", this._layer,
defaultValue: Diagnostics.kNullDefaultValue));
}
public virtual void showOnScreen(
RenderObject descendant = null,
Rect rect = null,
TimeSpan? duration = null,
Curve curve = null
) {
duration = duration ?? TimeSpan.Zero;
curve = curve ?? Curves.ease;
if (this.parent is RenderObject) {
RenderObject renderParent = (RenderObject) this.parent;
renderParent.showOnScreen(
descendant: descendant ?? this,
rect: rect,
duration: duration,
curve: curve
);
}
}
}
public interface RenderObjectWithChildMixin {
bool debugValidateChild(RenderObject child);
RenderObject child { get; set; }
}
public interface RenderObjectWithChildMixin<ChildType> : RenderObjectWithChildMixin
where ChildType : RenderObject {
new ChildType child { get; set; }
}
public interface ContainerParentDataMixin<ChildType> where ChildType : RenderObject {
ChildType previousSibling { get; set; }
ChildType nextSibling { get; set; }
}
public interface ContainerRenderObjectMixin {
int childCount { get; }
bool debugValidateChild(RenderObject child);
void insert(RenderObject child, RenderObject after = null);
void remove(RenderObject child);
void move(RenderObject child, RenderObject after = null);
RenderObject firstChild { get; }
RenderObject lastChild { get; }
RenderObject childBefore(RenderObject child);
RenderObject childAfter(RenderObject child);
}
public class UIWidgetsErrorDetailsForRendering : UIWidgetsErrorDetails {
public UIWidgetsErrorDetailsForRendering(
Exception exception = null,
string library = null,
string context = null,
RenderObject renderObject = null,
InformationCollector informationCollector = null,
bool silent = false
) : base(
exception: exception,
library: library,
context: context,
informationCollector: informationCollector,
silent: silent
) {
this.renderObject = renderObject;
}
public readonly RenderObject renderObject;
}
}