[1.5.4] Upgrade rendering objects.

Author: Yuncong Zhang

Runtime/rendering/debug.cs

@@ -0,0 +1,5 @@
+namespace Unity.UIWidgets.rendering {
+    public static class RenderingDebugUtils {
+        public static bool debugCheckElevationsEnabled = false;
+    }
+}

Runtime/rendering/debug.cs.meta

@@ -1245,7 +1245,7 @@ void _paintCaret(Canvas canvas, Offset effectiveOffset, TextPosition textPositio
             D.assert(this._textLayoutLastWidth == this.constraints.maxWidth);
             var paint = new Paint() {color = this._floatingCursorOn ? this.backgroundCursorColor : this._cursorColor};
             var caretOffset = this._textPainter.getOffsetForCaret(textPosition, this._caretPrototype) + effectiveOffset;
-            Rect caretRect = this._caretPrototype.shift(caretOffset + effectiveOffset);
+            Rect caretRect = this._caretPrototype.shift(caretOffset);
             if (this._cursorOffset != null) {
                 caretRect = caretRect.shift(this._cursorOffset);
             }

Runtime/rendering/editable.cs

@@ -29,7 +29,7 @@ public RenderErrorBox(string message = "") {
         );
 
         static ParagraphStyle paragraphStyle = new ParagraphStyle(
-            lineHeight: 1.0f
+            height: 1.0f
         );
     }
 }

Runtime/rendering/error.cs

@@ -385,6 +385,8 @@ protected override void performLayout() {
             if (totalFlex > 0 || this.crossAxisAlignment == CrossAxisAlignment.baseline) {
                 float spacePerFlex = canFlex && totalFlex > 0 ? (freeSpace / totalFlex) : float.NaN;
                 child = this.firstChild;
+                float maxSizeAboveBaseline = 0;
+                float maxSizeBelowBaseline = 0;
                 while (child != null) {
                     int flex = this._getFlex(child);
                     if (flex > 0) {
@@ -448,6 +450,9 @@ protected override void performLayout() {
                         float? distance = child.getDistanceToBaseline(this.textBaseline, onlyReal: true);
                         if (distance != null) {
                             maxBaselineDistance = Mathf.Max(maxBaselineDistance, distance.Value);
+                            maxSizeAboveBaseline = Mathf.Max(distance.Value, maxSizeAboveBaseline);
+                            maxSizeBelowBaseline = Mathf.Max(child.size.height - distance.Value, maxSizeBelowBaseline);
+                            crossSize = maxSizeAboveBaseline + maxSizeBelowBaseline;
                         }
                     }
 

Runtime/rendering/flex.cs

@@ -1,6 +1,6 @@
-using System;
-using System.Collections.Generic;
-using Unity.UIWidgets.external.simplejson;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
@@ -243,7 +243,7 @@ public Layer firstChild {
         public Layer lastChild {
             get { return this._lastChild; }
         }
-        
+
         internal override S find<S>(Offset regionOffset) {
             Layer current = this.lastChild;
             while (current != null) {
@@ -282,6 +282,95 @@ bool _debugUltimateNextSiblingOf(Layer child, Layer equals = null) {
             return child == equals;
         }
 
+        PictureLayer _highlightConflictingLayer(PhysicalModelLayer child) {
+            PictureRecorder recorder = new PictureRecorder();
+            var canvas = new RecorderCanvas(recorder);
+            canvas.drawPath(child.clipPath, new Paint() {
+                color = new Color(0xFFAA0000),
+                style = PaintingStyle.stroke,
+                strokeWidth = child.elevation + 10.0f,
+            });
+            PictureLayer pictureLayer = new PictureLayer(child.clipPath.getBounds());
+            pictureLayer.picture = recorder.endRecording();
+            pictureLayer.debugCreator = child;
+            child.append(pictureLayer);
+            return pictureLayer;
+        }
+
+        List<PictureLayer> _processConflictingPhysicalLayers(PhysicalModelLayer predecessor, PhysicalModelLayer child) {
+            UIWidgetsError.reportError(new UIWidgetsErrorDetails(
+                exception: new UIWidgetsError("Painting order is out of order with respect to elevation.\n" +
+                                              "See https://api.flutter.dev/flutter/rendering/debugCheckElevations.html " +
+                                              "for more details."),
+                context: "during compositing",
+                informationCollector: (StringBuilder builder) => {
+                    builder.AppendLine("Attempted to composite layer");
+                    builder.AppendLine(child.ToString());
+                    builder.AppendLine("after layer");
+                    builder.AppendLine(predecessor.ToString());
+                    builder.AppendLine("which occupies the same area at a higher elevation.");
+                }
+            ));
+            return new List<PictureLayer> {
+                this._highlightConflictingLayer(predecessor),
+                this._highlightConflictingLayer(child)
+            };
+        }
+
+        protected List<PictureLayer> _debugCheckElevations() {
+            List<PhysicalModelLayer> physicalModelLayers =
+                this.depthFirstIterateChildren().OfType<PhysicalModelLayer>().ToList();
+            List<PictureLayer> addedLayers = new List<PictureLayer>();
+
+            for (int i = 0; i < physicalModelLayers.Count; i++) {
+                PhysicalModelLayer physicalModelLayer = physicalModelLayers[i];
+                D.assert(physicalModelLayer.lastChild?.debugCreator != physicalModelLayer,
+                    () => "debugCheckElevations has either already visited this layer or failed to remove the" +
+                          " added picture from it.");
+                float accumulatedElevation = physicalModelLayer.elevation;
+                Layer ancestor = physicalModelLayer.parent;
+                while (ancestor != null) {
+                    if (ancestor is PhysicalModelLayer modelLayer) {
+                        accumulatedElevation += modelLayer.elevation;
+                    }
+
+                    ancestor = ancestor.parent;
+                }
+
+                for (int j = 0; j <= i; j++) {
+                    PhysicalModelLayer predecessor = physicalModelLayers[j];
+                    float predecessorAccumulatedElevation = predecessor.elevation;
+                    ancestor = predecessor.parent;
+                    while (ancestor != null) {
+                        if (ancestor == predecessor) {
+                            continue;
+                        }
+
+                        if (ancestor is PhysicalModelLayer modelLayer) {
+                            predecessorAccumulatedElevation += modelLayer.elevation;
+                        }
+
+                        ancestor = ancestor.parent;
+                    }
+
+                    if (predecessorAccumulatedElevation <= accumulatedElevation) {
+                        continue;
+                    }
+
+                    Path intersection = Path.combine(
+                        PathOperation.intersect,
+                        predecessor._debugTransformedClipPath,
+                        physicalModelLayer._debugTransformedClipPath);
+
+                    if (intersection != null && intersection.computeMetrics().Any((metric) => metric.length > 0)) {
+                        addedLayers.AddRange(this._processConflictingPhysicalLayers(predecessor, physicalModelLayer));
+                    }
+                }
+            }
+
+            return addedLayers;
+        }
+
         internal override void updateSubtreeNeedsAddToScene() {
             base.updateSubtreeNeedsAddToScene();
             Layer child = this.firstChild;
@@ -419,6 +508,25 @@ public virtual void applyTransform(Layer child, Matrix3 transform) {
             D.assert(transform != null);
         }
 
+        public List<Layer> depthFirstIterateChildren() {
+            if (this.firstChild == null) {
+                return new List<Layer>();
+            }
+
+            List<Layer> children = new List<Layer>();
+            Layer child = this.firstChild;
+            while (child != null) {
+                children.Add(child);
+                if (child is ContainerLayer containerLayer) {
+                    children.AddRange(containerLayer.depthFirstIterateChildren());
+                }
+
+                child = child.nextSibling;
+            }
+
+            return children;
+        }
+
         public override List<DiagnosticsNode> debugDescribeChildren() {
             var children = new List<DiagnosticsNode>();
             if (this.firstChild == null) {
@@ -470,9 +578,27 @@ public override void applyTransform(Layer child, Matrix3 transform) {
         }
 
         public Scene buildScene(SceneBuilder builder) {
+            List<PictureLayer> temporaryLayers = null;
+            D.assert(() => {
+                if (RenderingDebugUtils.debugCheckElevationsEnabled) {
+                    temporaryLayers = this._debugCheckElevations();
+                }
+
+                return true;
+            });
             this.updateSubtreeNeedsAddToScene();
             this.addToScene(builder);
-            return builder.build();
+            Scene scene = builder.build();
+            D.assert(() => {
+                if (temporaryLayers != null) {
+                    foreach (PictureLayer temporaryLayer in temporaryLayers) {
+                        temporaryLayer.remove();
+                    }
+                }
+
+                return true;
+            });
+            return scene;
         }
 
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
@@ -731,7 +857,7 @@ internal override S find<S>(Offset regionOffset) {
             if (this._invertedTransform == null) {
                 return null;
             }
-            
+
             Offset transform = this._invertedTransform.mapXY(regionOffset.dx, regionOffset.dy);
             return base.find<S>(transform);
         }
@@ -756,7 +882,13 @@ internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset
         public override void applyTransform(Layer child, Matrix3 transform) {
             D.assert(child != null);
             D.assert(transform != null);
-            transform.preConcat(this._lastEffectiveTransform);
+            D.assert(this._lastEffectiveTransform != null || this.transform != null);
+            if (this._lastEffectiveTransform == null) {
+                transform.preConcat(this.transform);
+            }
+            else {
+                transform.preConcat(this._lastEffectiveTransform);
+            }
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
@@ -822,7 +954,7 @@ public override void debugFillProperties(DiagnosticPropertiesBuilder properties)
             properties.add(new DiagnosticsProperty<Offset>("offset", this.offset));
         }
     }
-    
+
     public class BackdropFilterLayer : ContainerLayer {
         public BackdropFilterLayer(ImageFilter filter = null) {
             D.assert(filter != null);
@@ -1043,7 +1175,7 @@ void _establishTransform() {
         protected override bool alwaysNeedsAddToScene {
             get { return true; }
         }
-        
+
 
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
@@ -1217,6 +1349,20 @@ public Clip clipBehavior {
             }
         }
 
+        internal Path _debugTransformedClipPath {
+            get {
+                ContainerLayer ancestor = this.parent;
+                Matrix3 matrix = Matrix3.I();
+                while (ancestor != null && ancestor.parent != null) {
+                    ancestor.applyTransform(this, matrix);
+                    ancestor = ancestor.parent;
+                }
+
+                return this.clipPath.transform(matrix);
+            }
+        }
+
+
         Clip _clipBehavior;
 
         public float elevation {

Runtime/rendering/layer.cs

@@ -7,6 +7,7 @@
 using Unity.UIWidgets.ui;
 using UnityEngine;
 using Canvas = Unity.UIWidgets.ui.Canvas;
+using Color = Unity.UIWidgets.ui.Color;
 using Rect = Unity.UIWidgets.ui.Rect;
 
 namespace Unity.UIWidgets.rendering {
@@ -196,7 +197,7 @@ protected virtual void stopRecordingIfNeeded() {
                     Paint paint = new Paint {
                         style = PaintingStyle.stroke,
                         strokeWidth = 1.0f,
-                        color = new ui.Color(0xFFFF9800),
+                        color = new Color(0xFFFF9800),
                     };
                     this.canvas.drawRect(this.estimatedBounds, paint);
                 }
@@ -288,7 +289,8 @@ public void pushTransform(bool needsCompositing, Offset offset, Matrix3 transfor
             Matrix3 effectiveTransform;
             if (offset == null || offset == Offset.zero) {
                 effectiveTransform = transform;
-            } else {
+            }
+            else {
                 effectiveTransform = Matrix3.makeTrans(offset.dx, offset.dy);
                 effectiveTransform.preConcat(transform);
                 effectiveTransform.preTranslate(-offset.dx, -offset.dy);
@@ -297,7 +299,7 @@ public void pushTransform(bool needsCompositing, Offset offset, Matrix3 transfor
             if (needsCompositing) {
                 var inverse = Matrix3.I();
                 var invertible = effectiveTransform.invert(inverse);
-                
+
                 // it could just be "scale == 0", ignore the assertion.
                 // D.assert(invertible);
 
@@ -1377,6 +1379,7 @@ public override string toStringShallow(
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+            base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<object>(
                 "creator", this.debugCreator, defaultValue: Diagnostics.kNullDefaultValue,
                 level: DiagnosticLevel.debug));