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

com.unity.uiwidgets/Runtime/rendering/RenderAnimatedOpacityMixin.mixin.gen.cs

-using System;
-using Unity.UIWidgets.gestures;
-using Unity.UIWidgets.painting;
+
-     public abstract class RenderAnimatedOpacityMixinRenderSliver<ChildType> : RenderProxySliver,  RenderAnimatedOpacityMixin<ChildType> where ChildType : RenderObject {
-         
-         
-         public int _alpha { get; set; }
-
-         public new bool alwaysNeedsCompositing {
+     public abstract class RenderAnimatedOpacityMixinRenderSliver<ChildType> : RenderProxySliver, RenderAnimatedOpacityMixin<ChildType> where ChildType : RenderObject {
+        
+           
+        public int _alpha { get; set;}
+        public new bool alwaysNeedsCompositing {
-
-         public bool _currentlyNeedsCompositing { get; set; }
-
-        
+         public bool _currentlyNeedsCompositing { get;set; }
 
         public Animation<float> opacity {
             get { return _opacity; }
                 _updateOpacity();
             }
         }
-
+
+
         public bool alwaysIncludeSemantics {
             get { return _alwaysIncludeSemantics; }
             set { 
                 
             }
         }
-
-        public bool _alwaysIncludeSemantics { get; set; }
-
-        public override void attach(object owner) {
-            owner = (PipelineOwner) owner;
-            base.attach(owner);
-            _opacity.addListener(_updateOpacity);
-            _updateOpacity(); 
-        }
-
+       public bool _alwaysIncludeSemantics { get; set; }
+        
-            _updateOpacity(); 
+            _updateOpacity();
-
+        
         public override void detach() {
             _opacity.removeListener(_updateOpacity);
             base.detach();
                 markNeedsPaint(); 
                 //if (oldAlpha == 0 || _alpha == 0) 
                 //    markNeedsSemanticsUpdate();
+              
             }
         }
         public override void paint(PaintingContext context, Offset offset) {
                 layer = context.pushOpacity(offset, _alpha, base.paint, oldLayer: layer as OpacityLayer);
             }
         }
-
-       
+        
-
+        
-
-
+        
+        public bool debugValidateChild(RenderObject child) {
+            D.assert(() => {
+                if (!(child is ChildType)) {
+                    throw new UIWidgetsError(new List<DiagnosticsNode>{
+                        new ErrorSummary(
+                            $"A {GetType()} expected a child of type {typeof(ChildType)} but received a " +
+                            $"child of type {child.GetType()}."
+                        ),
+                        new ErrorDescription(
+                            "RenderObjects expect specific types of children because they " +
+                            "coordinate with their children during layout and paint. For " +
+                            "example, a RenderSliver cannot be the child of a RenderBox because " +
+                            "a RenderSliver does not understand the RenderBox layout protocol."
+                        ),
+                        new ErrorSpacer(),
+                        new DiagnosticsProperty<dynamic>(
+                            "The $runtimeType that expected a $ChildType child was created by",
+                            debugCreator,
+                            style: DiagnosticsTreeStyle.errorProperty
+                        ),
+                        new ErrorSpacer(),
+                        new DiagnosticsProperty<dynamic>(
+                            "The ${child.runtimeType} that did not match the expected child type " +
+                            "was created by",
+                            child.debugCreator,
+                            style: DiagnosticsTreeStyle.errorProperty
+                        ),
+                    });
+                }
+                return true;
+            });
+            return true;
+        }
+        
+        
+        RenderObject RenderObjectWithChildMixin.child {
+            get { return child; }
+            set { child = (ChildType) value; }
+        }
+
      }
 
 

com.unity.uiwidgets/Runtime/rendering/RenderAnimatedOpacityMixin.mixin.njk

+using System.Collections.Generic;
+using Unity.UIWidgets.animation;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.ui;
+
-     public abstract class RenderAnimatedOpacityMixin{{with}}<ChildType> : {{with}}, RenderAnimatedOpacityMixin<ChildType> where ChildType : RenderSliver {
+     public abstract class RenderAnimatedOpacityMixin{{with}}<ChildType> : RenderProxySliver, RenderAnimatedOpacityMixin<ChildType> where ChildType : RenderObject {
-            get { child != null && _currentlyNeedsCompositing;}
+            get { return child != null && _currentlyNeedsCompositing;}
         }
          public bool _currentlyNeedsCompositing { get;set; }
 
         }
        public bool _alwaysIncludeSemantics { get; set; }
         
-        public override void attach(PipelineOwner owner) {
+        public void attach(PipelineOwner owner) {
-            _updateOpacity(); 
+            _updateOpacity();
+        
         public override void detach() {
             _opacity.removeListener(_updateOpacity);
             base.detach();
             base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<Animation<float>>("opacity", opacity));
             properties.add(new FlagProperty("alwaysIncludeSemantics", value: alwaysIncludeSemantics, ifTrue: "alwaysIncludeSemantics"));
+        }
+        
+        public bool debugValidateChild(RenderObject child) {
+            D.assert(() => {
+                if (!(child is ChildType)) {
+                    throw new UIWidgetsError(new List<DiagnosticsNode>{
+                        new ErrorSummary(
+                            $"A {GetType()} expected a child of type {typeof(ChildType)} but received a " +
+                            $"child of type {child.GetType()}."
+                        ),
+                        new ErrorDescription(
+                            "RenderObjects expect specific types of children because they " +
+                            "coordinate with their children during layout and paint. For " +
+                            "example, a RenderSliver cannot be the child of a RenderBox because " +
+                            "a RenderSliver does not understand the RenderBox layout protocol."
+                        ),
+                        new ErrorSpacer(),
+                        new DiagnosticsProperty<dynamic>(
+                            "The $runtimeType that expected a $ChildType child was created by",
+                            debugCreator,
+                            style: DiagnosticsTreeStyle.errorProperty
+                        ),
+                        new ErrorSpacer(),
+                        new DiagnosticsProperty<dynamic>(
+                            "The ${child.runtimeType} that did not match the expected child type " +
+                            "was created by",
+                            child.debugCreator,
+                            style: DiagnosticsTreeStyle.errorProperty
+                        ),
+                    });
+                }
+                return true;
+            });
+            return true;
+        }
+        
+        public ChildType child { get; set; }
+        
+        RenderObject RenderObjectWithChildMixin.child {
+            get { return child; }
+            set { child = (ChildType) value; }
         }
 
      }

com.unity.uiwidgets/Runtime/rendering/debug.cs

 
 namespace Unity.UIWidgets.rendering {
     public static class RenderingDebugUtils {
+        public static bool debugDisableShadows = false;
         public static bool debugCheckElevationsEnabled = false;
         public static bool debugRepaintTextRainbowEnabled = false;
         static readonly HSVColor _kDebugDefaultRepaintColor = HSVColor.fromAHSV(0.4f, 60.0f, 1.0f, 1.0f);

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

         }
     }
 
-    public class RenderEditable : RenderBox, RelayoutWhenSystemFontsChangeMixin {
+    public class RenderEditable : RelayoutWhenSystemFontsChangeMixinRenderBox {
         public RenderEditable(
             TextSpan text = null, 
             TextDirection? textDirection = null,
             return true;
         }
 
-        public void attach(PipelineOwner owner) {
-            _tap = new TapGestureRecognizer(debugOwner: this);
-            _tap.onTapDown = _handleTapDown;
-            _tap.onTap = _handleTap;
-            _longPress = new LongPressGestureRecognizer(debugOwner: this);
-            _longPress.onLongPress = _handleLongPress;
-            _offset.addListener(markNeedsLayout);
-            _showCursor.addListener(markNeedsPaint);
-        }
-        
         string _cachedPlainText;
         string _plainText {
             get {
 
         public override void attach(object ownerObject) {
             base.attach(ownerObject);
-            attach((PipelineOwner)ownerObject);
-            /*_tap = new TapGestureRecognizer(debugOwner: this);
+            _tap = new TapGestureRecognizer(debugOwner: this);
-            _showCursor.addListener(markNeedsPaint);*/
+            _showCursor.addListener(markNeedsPaint);
         }
 
         public override void detach() {

com.unity.uiwidgets/Runtime/rendering/object.cs

             _needsCompositingBitsUpdate = false;
         }
 
-        bool debugNeedsPaint {
+        public bool debugNeedsPaint {
             get {
                 bool result = false;
                 D.assert(() => {
         RenderObject lastChild { get; }
         RenderObject childBefore(RenderObject child);
         RenderObject childAfter(RenderObject child);
-    }
-
-    public interface RelayoutWhenSystemFontsChangeMixin {
-        void systemFontsDidChange();
-        void attach(PipelineOwner owner);
-        void detach();
     }
 
     public class UIWidgetsErrorDetailsForRendering : UIWidgetsErrorDetails {

com.unity.uiwidgets/Runtime/rendering/object.mixin.gen.cs

 
 using System.Collections.Generic;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.painting;
 using Unity.UIWidgets.widgets;
 using UnityEngine;
 
-        public bool debugValidateChild(RenderObject child) {
+        public virtual bool debugValidateChild(RenderObject child) {
             D.assert(() => {
                 if (!(child is ChildType)) {
                     throw new UIWidgetsError(
 
 
     public abstract class RenderObjectWithChildMixinRenderBox<ChildType> : RenderBox, RenderObjectWithChildMixin<ChildType>, RenderObjectWithChildMixin where ChildType : RenderObject {
-        public bool debugValidateChild(RenderObject child) {
+        public virtual bool debugValidateChild(RenderObject child) {
             D.assert(() => {
                 if (!(child is ChildType)) {
                     throw new UIWidgetsError(
 
         public virtual void insert(ChildType child, ChildType after = null) {
             D.assert(child != this, ()=>"A RenderObject cannot be inserted into itself.");
-            D.assert(after != this,()=>
-                "A RenderObject cannot simultaneously be both the parent and the sibling of another RenderObject.");
+            D.assert(after != this,
+                ()=>"A RenderObject cannot simultaneously be both the parent and the sibling of another RenderObject.");
-
             adoptChild(child);
             _insertIntoChildList(child, after);
         }
 
         public virtual void insert(ChildType child, ChildType after = null) {
             D.assert(child != this, ()=>"A RenderObject cannot be inserted into itself.");
-            D.assert(after != this,()=>
-                "A RenderObject cannot simultaneously be both the parent and the sibling of another RenderObject.");
+            D.assert(after != this,
+                ()=>"A RenderObject cannot simultaneously be both the parent and the sibling of another RenderObject.");
-
             adoptChild(child);
             _insertIntoChildList(child, after);
         }
         public virtual void insert(ChildType child, ChildType after = null) {
             D.assert(child != this, ()=>"A RenderObject cannot be inserted into itself.");
             D.assert(after != this,
-               ()=> "A RenderObject cannot simultaneously be both the parent and the sibling of another RenderObject.");
-            D.assert(child != after,()=> "A RenderObject cannot be inserted after itself.");
+                ()=>"A RenderObject cannot simultaneously be both the parent and the sibling of another RenderObject.");
+            D.assert(child != after, ()=>"A RenderObject cannot be inserted after itself.");
-
             adoptChild(child);
             _insertIntoChildList(child, after);
         }
             invokeLayoutCallback(_callback);
         }
     }
+
+
+    
+     
+    public abstract class RelayoutWhenSystemFontsChangeMixinRenderBox : RenderBox {
+    
+        protected void systemFontsDidChange() {
+            markNeedsLayout();
+        }
+        
+        public override void attach(object owner) {
+            base.attach(owner);
+            PaintingBinding.instance.systemFonts.addListener(systemFontsDidChange);
+          }
+        
+        public override void detach() {
+            PaintingBinding.instance.systemFonts.removeListener(systemFontsDidChange);
+            base.detach();
+        }
+        
+    }  
 
 }

com.unity.uiwidgets/Runtime/rendering/object.mixin.njk

 
 using System.Collections.Generic;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.painting;
 using Unity.UIWidgets.widgets;
 using UnityEngine;
 
 {{ RenderConstrainedLayoutBuilderMixin('abstract', 'RenderObject', 'Constraints') }}
 {{ RenderConstrainedLayoutBuilderMixin('', 'RenderBox', 'BoxConstraints') }}
 {{ RenderConstrainedLayoutBuilderMixin('abstract', 'RenderSliver', 'SliverConstraints') }}
+
+{% macro RelayoutWhenSystemFontsChangeMixin(with) %} 
+    public abstract class RelayoutWhenSystemFontsChangeMixin{{with}} : {{with}} {
+    
+        protected void systemFontsDidChange() {
+            markNeedsLayout();
+        }
+        
+        public override void attach(object owner) {
+            base.attach(owner);
+            PaintingBinding.instance.systemFonts.addListener(systemFontsDidChange);
+          }
+        
+        public override void detach() {
+            PaintingBinding.instance.systemFonts.removeListener(systemFontsDidChange);
+            base.detach();
+        }
+        
+    }  
+    {% endmacro %}
+    
+    {{ RelayoutWhenSystemFontsChangeMixin('RenderBox') }}
 }

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

                         _needsClipping = true;
                         break;
                 }*/
+                //[!!!]need to replace it?
                 switch (_overflow) {
                     case TextOverflow.visible:
                         _needsClipping = false;
                 paintParagraph(context, offset);
             }
         } */
+        // need to replace it?
-        public override void paint(PaintingContext context2, Offset offset2) {
+        public override void paint(PaintingContext context, Offset offset) {
               _layoutTextWithConstraints(constraints);
 
             D.assert(() => {
-                context2.canvas.drawRect(offset2 & size, paint);
+                context.canvas.drawRect(offset & size, paint);
-              Rect bounds = offset2 & size;
+              Rect bounds = offset & size;
-                  context2.canvas.saveLayer(bounds, new Paint());
+                  context.canvas.saveLayer(bounds, new Paint());
-                context2.canvas.save();
+                context.canvas.save();
-              context2.canvas.clipRect(bounds);
+              context.canvas.clipRect(bounds);
-            _textPainter.paint(context2.canvas, offset2);
+            _textPainter.paint(context.canvas, offset);
 
             RenderBox child = firstChild;
             int childIndex = 0;
                 float scale = textParentData.scale;
-                context2.pushTransform(
+                context.pushTransform(
-                    offset2 + textParentData.offset,
+                    offset + textParentData.offset,
-                    (PaintingContext context, Offset offset) => {
-                    context.paintChild(
+                    (PaintingContext context2, Offset offset2) => {
+                    context2.paintChild(
-                        offset
+                        offset2
-                }
-                );
+                });
-                    context2.canvas.translate(offset2.dx, offset2.dy);
+                    context.canvas.translate(offset.dx, offset.dy);
-                    context2.canvas.drawRect(Offset.zero & size, paint);
+                    context.canvas.drawRect(Offset.zero & size, paint);
-                context2.canvas.restore();
+                context.canvas.restore();
             }
         }
 
             _textPainter.layout(minWidth, widthMatters ? maxWidth : float.PositiveInfinity);
         }
 
+        /*public override void systemFontsDidChange() {
+            base.systemFontsDidChange();
+            _textPainter.markNeedsLayout();
+        }*/
+        
         List<PlaceholderDimensions> _placeholderDimensions;
         
         void _layoutTextWithConstraints(BoxConstraints constraints) {

com.unity.uiwidgets/Runtime/rendering/performance_overlay.cs

             bool checkerboardRasterCacheImages = false,
             bool checkerboardOffscreenLayers = false
         ) {
-            D.assert(optionsMask != null);
-            D.assert(rasterizerThreshold != null);
-            D.assert(checkerboardRasterCacheImages != null);
-            D.assert(checkerboardOffscreenLayers != null);
             _optionsMask = optionsMask;
             _rasterizerThreshold = rasterizerThreshold;
             _checkerboardRasterCacheImages = checkerboardRasterCacheImages;
                 return _rasterizerThreshold;
             }
             set {
-                D.assert(value != null);
                 if (value == _rasterizerThreshold)
                     return;
                 _rasterizerThreshold = value;
                 return _checkerboardRasterCacheImages;
             }
             set {
-                D.assert(value != null);
                 if (value == _checkerboardRasterCacheImages)
                     return;
                 _checkerboardRasterCacheImages = value;
         public bool checkerboardOffscreenLayers {
             get { return _checkerboardOffscreenLayers; }
             set {
-                D.assert(value != null);
                 if (value == _checkerboardOffscreenLayers)
                     return;
                 _checkerboardOffscreenLayers = value;

com.unity.uiwidgets/Runtime/rendering/proxy_box.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.animation;
+using Unity.UIWidgets.async2;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;
             BlendMode blendMode = BlendMode.modulate
             ) : base(child) {
             D.assert(shaderCallback != null);
-            D.assert(blendMode != null);
             _shaderCallback = shaderCallback;
             _blendMode = blendMode;
         }
         public BlendMode blendMode {
             get { return _blendMode;}
             set {
-                D.assert(value != null);
                 if (_blendMode == value)
                     return;
                 _blendMode = value;
             get;
         }
         bool _currentlyNeedsCompositing { get; set; }
-        Animation<float> opacity {
-            get;
-            set;
-        }
-
-        Animation<float> _opacity { get; set; }
-
-
-        bool alwaysIncludeSemantics {
+        Animation<float> _opacity {
-        bool _alwaysIncludeSemantics { get; set; } 
         void attach(PipelineOwner owner);
         void detach();
 
         }
 
         protected override void performLayout() {
+            BoxConstraints constraints = this.constraints;
             if (child != null) {
                 child.layout(_additionalConstraints.enforce(constraints), parentUsesSize: true);
                 size = child.size;
 
         protected override void performLayout() {
             if (child != null) {
+                BoxConstraints constraints = this.constraints;
                 child.layout(_limitConstraints(constraints), parentUsesSize: true);
                 size = constraints.constrain(child.size);
             }
         public RenderAspectRatio(
             float aspectRatio, 
             RenderBox child = null) : base(child) {
+            D.assert(aspectRatio > 0.0);
+            D.assert(aspectRatio.isFinite());
             _aspectRatio = aspectRatio;
         }
 
             float width = constraints.maxWidth;
             float height = width / _aspectRatio;
 
+            if (width.isFinite()) {
+                height = width / _aspectRatio;
+            } else {
+                height = constraints.maxHeight;
+                width = height * _aspectRatio;
+            }
+            
             if (width > constraints.maxWidth) {
                 width = constraints.maxWidth;
                 height = width / _aspectRatio;
         public override void paint(PaintingContext context, Offset offset) {
             if (child != null) {
                 if (_alpha == 0) {
+                    layer = null;
+                layer = null;
-            context.pushOpacity(offset, _alpha, base.paint);
+            layer = context.pushOpacity(offset, _alpha, base.paint, oldLayer: layer as OpacityLayer);
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
         public override void paint(PaintingContext context, Offset offset) {
             if (child != null) {
                 D.assert(needsCompositing);
-                context.pushLayer(new BackdropFilterLayer(filter), base.paint, offset);
+                layer = layer?? new BackdropFilterLayer(_filter);
+                context.pushLayer(layer, base.paint, offset);
+            } else {
+                layer = null;
             }
         }
     }
                 }
 
                 _clipBehavior = value;
+                markNeedsPaint();
             }
         }
         
                         new List<Color> {
                             new Color(0x00000000),
                             new Color(0xFFFF00FF),
-                        }, null, TileMode.repeated);
+                            new Color(0xFFFF00FF), 
+                            new Color(0x00000000)
+                        }, 
+                        new List<float>{0.25f,0.25f,0.75f,0.75f},
+                        TileMode.repeated);
                     _debugPaint.strokeWidth = 2.0f;
                     _debugPaint.style = PaintingStyle.stroke;
                 }
                         text: new TextSpan(
-                            text: "x",
+                            text: "✂",
-                        ));
+                        ),
+                        textDirection: TextDirection.rtl
+                    );
                     _debugText.layout();
                 }
 
             child: child,
             clipper: clipper,
             clipBehavior: clipBehavior) {
+            D.assert(clipBehavior != Clip.none);
         }
 
         protected override Rect _defaultClip {
         public override void paint(PaintingContext context, Offset offset) {
             if (child != null) {
                 _updateClip();
-                context.pushClipRect(needsCompositing, offset, _clip,
-                    base.paint, clipBehavior: clipBehavior);
+                layer = context.pushClipRect(
+                    needsCompositing,
+                    offset,
+                    _clip,
+                    base.paint,
+                    clipBehavior: clipBehavior,
+                    oldLayer: layer as ClipRectLayer
+                );
+            } else {
+                layer = null;
             }
         }
 
         public override void paint(PaintingContext context, Offset offset) {
             if (child != null) {
                 _updateClip();
-                context.pushClipRRect(needsCompositing, offset, _clip.outerRect, _clip,
-                    base.paint, clipBehavior: clipBehavior);
+                layer = context.pushClipRRect(
+                    needsCompositing,
+                    offset,
+                    _clip.outerRect,
+                    _clip,
+                    base.paint, 
+                    clipBehavior: clipBehavior, 
+                    oldLayer: layer as ClipRRectLayer
+                );
+            } else {
+                layer = null;
             }
         }
 
             get { return Offset.zero & size; }
         }
 
-        public override bool hitTest(BoxHitTestResult result,
-            Offset position = null
-        ) {
+        public override bool hitTest(BoxHitTestResult result, Offset position = null) {
             _updateClip();
             D.assert(_clip != null);
             Offset center = _clip.center;
         public override void paint(PaintingContext context, Offset offset) {
             if (child != null) {
                 _updateClip();
-                context.pushClipPath(needsCompositing, offset, _clip, _getClipPath(_clip),
-                    base.paint, clipBehavior: clipBehavior);
+                layer = context.pushClipPath(
+                    needsCompositing,
+                    offset,
+                    _clip,
+                    _getClipPath(_clip),
+                    base.paint,
+                    clipBehavior: clipBehavior,
+                    oldLayer: layer as ClipPathLayer
+                );
+            } else {
+                layer = null;
             }
         }
 
         public override void paint(PaintingContext context, Offset offset) {
             if (child != null) {
                 _updateClip();
-                context.pushClipPath(needsCompositing, offset, Offset.zero & size,
-                    _clip, base.paint, clipBehavior: clipBehavior);
+                layer = context.pushClipPath(
+                    needsCompositing,
+                    offset,
+                    Offset.zero & size,
+                    _clip,
+                    base.paint,
+                    clipBehavior: clipBehavior,
+                    oldLayer: layer as ClipPathLayer
+                );
+            } else {
+                layer = null;
             }
         }
 
             _shape = shape;
             _borderRadius = borderRadius;
         }
+        
+        public PhysicalModelLayer layer { // [!!!] override
+            get {
+                return base.layer as PhysicalModelLayer;
+            }
+            set {
+                if (layer == value) {
+                    return;
+                }
+
+                base.layer = value;
+            }
+        }
 
         public BoxShape shape {
             get { return _shape; }
                 Rect offsetBounds = offsetRRect.outerRect;
                 Path offsetRRectAsPath = new Path();
                 offsetRRectAsPath.addRRect(offsetRRect);
-
-                PhysicalModelLayer physicalModel = new PhysicalModelLayer(
-                    clipPath: offsetRRectAsPath,
-                    clipBehavior: clipBehavior,
-                    elevation: elevation,
-                    color: color,
-                    shadowColor: shadowColor);
+                bool paintShadows = true;
-                    physicalModel.debugCreator = debugCreator;
+                    if (RenderingDebugUtils.debugDisableShadows) {
+                        if (elevation > 0.0) {
+                            Paint paint = new Paint();
+                            paint.color = shadowColor;
+                            paint.style = PaintingStyle.stroke;
+                            paint.strokeWidth = elevation * 2.0f;
+                            context.canvas.drawRRect(
+                                offsetRRect,
+                                paint
+                            );
+                        }
+                        paintShadows = false;
+                    }
-                context.pushLayer(physicalModel, base.paint, offset, childPaintBounds: offsetBounds);
+                layer = layer?? new PhysicalModelLayer();
+                layer.clipPath = offsetRRectAsPath;
+                layer.clipBehavior = clipBehavior;
+                layer.elevation = paintShadows ? elevation : 0.0f;
+                layer.color = color;
+                layer.shadowColor = shadowColor;
+                context.pushLayer(layer, base.paint, offset, childPaintBounds: offsetBounds);
+                D.assert(() => {
+                    layer.debugCreator = debugCreator;
+                    return true;
+                });
+            } else {
+                layer = null;
             }
         }
 
             clipBehavior: clipBehavior) {
             D.assert(clipper != null);
             D.assert(color != null);
+            D.assert(elevation >= 0.0);
+        }
+
+        public PhysicalModelLayer layer { // [!!!] override
+            get {
+                return base.layer as PhysicalModelLayer;
+            }
+            set {
+                if (layer == value) {
+                    return;
+                }
+
+                base.layer = value;
+            }
         }
 
         protected override Path _defaultClip {
                 _updateClip();
                 Rect offsetBounds = offset & size;
                 Path offsetPath = _clip.shift(offset);
-
-                PhysicalModelLayer physicalModel = new PhysicalModelLayer(
-                    clipPath: offsetPath,
-                    clipBehavior: clipBehavior,
-                    elevation: elevation,
-                    color: color,
-                    shadowColor: shadowColor);
-                
-                context.pushLayer(physicalModel, base.paint, offset, childPaintBounds: offsetBounds);
+                bool paintShadows = true;
+                D.assert(() => {
+                    if (RenderingDebugUtils.debugDisableShadows) {
+                        if (elevation > 0.0) {
+                            Paint paint = new Paint();
+                            paint.color = shadowColor;
+                            paint.style = PaintingStyle.stroke;
+                            paint.strokeWidth = elevation * 2.0f;
+                            context.canvas.drawPath(
+                                offsetPath,
+                                paint  
+                            );
+                        }
+                        paintShadows = false;
+                    }
+                    return true;
+                });
+                layer = layer?? new PhysicalModelLayer();
+                layer.clipPath = offsetPath;
+                layer.clipBehavior = clipBehavior;
+                layer.elevation = paintShadows ? elevation : 0.0f;
+                layer.color = color;
+                layer.shadowColor = shadowColor;
+                context.pushLayer(layer, base.paint, offset, childPaintBounds: offsetBounds);
+                D.assert(() => {
+                    layer.debugCreator = debugCreator;
+                    return true;
+                });
+            } else {
+                layer = null;
             }
         }
 
 
         protected override bool hitTestSelf(Offset position) {
             return _decoration.hitTest(size, position);
+            // [!!!] hitTest no textDirection
+            // return _decoration.hitTest(size, position, textDirection: configuration.textDirection);
         }
 
         public override void paint(PaintingContext context, Offset offset) {
 
                 D.assert(() => {
                     if (debugSaveCount != context.canvas.getSaveCount()) {
-                        throw new UIWidgetsError(
-                            _decoration.GetType() + " painter had mismatching save and restore calls.\n" +
-                            "Before painting the decoration, the canvas save count was $debugSaveCount. " +
-                            "After painting it, the canvas save count was " + context.canvas.getSaveCount() + ". " +
-                            "Every call to save() or saveLayer() must be matched by a call to restore().\n" +
-                            "The decoration was:\n" +
-                            "  " + decoration + "\n" +
-                            "The painter was:\n" +
-                            "  " + _painter
-                        );
+                        throw new UIWidgetsError(new List<DiagnosticsNode>{
+                            new ErrorSummary($"{_decoration.GetType()} painter had mismatching save and restore calls."),
+                            new ErrorDescription(
+                                "Before painting the decoration, the canvas save count was $debugSaveCount. " +
+                                "After painting it, the canvas save count was ${context.canvas.getSaveCount()}. " +
+                                "Every call to save() or saveLayer() must be matched by a call to restore()."
+                            ),
+                            new DiagnosticsProperty<Decoration>("The decoration was", decoration, style: DiagnosticsTreeStyle.errorProperty),
+                            new DiagnosticsProperty<BoxPainter>("The painter was", _painter, style: DiagnosticsTreeStyle.errorProperty),
+                        });
                     }
 
                     return true;
             bool transformHitTests = true,
             RenderBox child = null
         ) : base(child) {
+            D.assert(transform != null);
             this.transform = transform;
             this.origin = origin;
             this.alignment = alignment;
                     return;
                 _textDirection = value;
                 markNeedsPaint();
-                //markNeedsSemanticsUpdate();
             }
         }
 
                 }
 
                 _transform = value;
+                //_transform = Matrix4.copy(value);
                 markNeedsPaint();
             }
         }
         public void setIdentity() {
+            _transform.setIdentity();
             _transform = Matrix4.identity();
             markNeedsPaint();
         }
                 Offset childOffset = transform.getAsTranslation();
 
                 if (childOffset == null) {
-                    context.pushTransform(needsCompositing, offset, transform, base.paint);
-                }
-                else {
+                    layer = context.pushTransform(
+                        needsCompositing,
+                        offset,
+                        transform,
+                        base.paint,
+                        oldLayer: layer as TransformLayer
+                    );
+                } else {
+                    layer = null;
                 }
             }
         }
                 Rect sourceRect = _resolvedAlignment.inscribe(sizes.source, Offset.zero & childSize);
                 Rect destinationRect = _resolvedAlignment.inscribe(sizes.destination, Offset.zero & size);
                 _hasVisualOverflow = sourceRect.width < childSize.width || sourceRect.height < childSize.height;
+                D.assert(scaleX.isFinite() && scaleY.isFinite());
+                bool result = true;
+                foreach (var value in _transform.storage) {
+                    if (!value.isFinite()) {
+                        result = false;
+                    }
+                }
+                D.assert(result);
+        
-                context.pushTransform(needsCompositing, offset, _transform, base.paint);
+                context.pushTransform(needsCompositing, offset, _transform, base.paint,
+                    oldLayer: layer is TransformLayer ? layer as TransformLayer : null);
+        /*TransformLayer _paintChildWithTransform(PaintingContext context, Offset offset) {
+            Offset childOffset = _transform.getAsTranslation();
+            if (childOffset == null) {
+                return context.pushTransform(needsCompositing, offset, _transform, base.paint,
+                    oldLayer: layer is TransformLayer ? layer as TransformLayer : null);
+            }
+            else {
+                base.paint(context, offset + childOffset);
+                return null;
+            }
+        }*/
+        //[!!!]
-            if (size.isEmpty) {
+            if (size.isEmpty || child.size.isEmpty) {
                 return;
             }
 
                     context.pushClipRect(needsCompositing, offset, Offset.zero & size,
-                        _paintChildWithTransform);
+                        painter: _paintChildWithTransform,
+                        oldLayer: layer is ClipRectLayer ? layer as ClipRectLayer : null);
-                else {
+                else{
                     _paintChildWithTransform(context, offset);
                 }
             }
         }
 
         public override void applyPaintTransform(RenderObject child, Matrix4 transform) {
-            if (size.isEmpty) {
+            if (size.isEmpty || ((RenderBox)child).size.isEmpty) {
                 transform.setZero();
             }
             else {
 
         Offset _translation;
 
-        public override bool hitTest(BoxHitTestResult result, Offset position) {
+        public override bool hitTest(BoxHitTestResult result, Offset position = null) {
-        protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
+        protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
             D.assert(!debugNeedsLayout);
             return result.addWithPaintOffset(
                 offset: transformHitTests
                     {"cancel", onPointerCancel},
                     {"signal", onPointerSignal}
                 },
-                ifEmpty: "<none>"));
+                ifEmpty: "<none>"
+            ));
         }
     }
 
             bool opaque = true,
             RenderBox child = null
         ) : base(child) {
-            D.assert(opaque != null);
             _onEnter = onEnter;
             _onHover = onHover;
             _onExit = onExit;
             }
         }
         PointerEnterEventListener _onEnter; 
-        public void _handleEnter(PointerEnterEvent Event) { 
+        public void _handleEnter(PointerEnterEvent _event) { 
-              _onEnter(Event);
+              _onEnter(_event);
         }
 
         public PointerHoverEventListener onHover {
         }
 
         PointerHoverEventListener _onHover; 
-        void _handleHover(PointerHoverEvent Event) {
+        void _handleHover(PointerHoverEvent _event) {
-                _onHover(Event);
+                _onHover(_event);
         }
 
         public PointerExitEventListener onExit {
         }
 
         PointerExitEventListener _onExit; 
-        void _handleExit(PointerExitEvent Event) {
+        void _handleExit(PointerExitEvent _event) {
-                _onExit(Event);
+                _onExit(_event);
         }
         
         MouseTrackerAnnotation _hoverAnnotation;
             owner = (PipelineOwner)owner;
             base.attach(owner);
             // todo
-            //RendererBinding.instance.mouseTracker.addListener(_handleUpdatedMouseIsConnected);
+            RendererBinding.instance.mouseTracker.addListener(_handleUpdatedMouseIsConnected);
-           // RendererBinding.instance.mouseTracker.removeListener(_handleUpdatedMouseIsConnected);
+            RendererBinding.instance.mouseTracker.removeListener(_handleUpdatedMouseIsConnected);
             base.detach();
         }
         public bool _annotationIsActive;
               AnnotatedRegionLayer<MouseTrackerAnnotation> layer = new AnnotatedRegionLayer<MouseTrackerAnnotation>(
                 _hoverAnnotation,
                 size: size,
-                offset: offset
-                //opaque: opaque  // todo
+                offset: offset,
+                opaque: opaque // TODO
               );
               context.pushLayer(layer, base.paint, offset);
             } else {
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             // todo
-           /* properties.add(FlagsSummary<Function>(
+            properties.add(new FlagsSummary<Delegate>(
-              <string, Function>{
-                "enter": onEnter,
-                "hover": onHover,
-                "exit": onExit,
-              }
-              ifEmpty: "<none>",
-            ));*/
+              new Dictionary<string, Delegate>{
+                  {"enter", onEnter},
+                  {"hover", onHover},
+                  {"exit", onExit},
+              },
+              ifEmpty: "<none>"
+            ));
             properties.add(new DiagnosticsProperty<bool>("opaque", opaque, defaultValue: true));
         }
     }
         public override bool isRepaintBoundary {
             get { return true; }
         }
+        
+        Future<ui.Image> toImage( float pixelRatio = 1.0f) {
+            D.assert(!debugNeedsPaint);
+            OffsetLayer offsetLayer = layer as OffsetLayer;
+            return offsetLayer.toImage(Offset.zero & size, pixelRatio: pixelRatio);
+        }
 
         public int debugSymmetricPaintCount {
             get { return _debugSymmetricPaintCount; }
         bool _ignoring;
 
         public override bool hitTest(BoxHitTestResult result, Offset position = null) {
-            return ignoring ? false : base.hitTest(result, position: position);
+            return !ignoring && base.hitTest(result, position: position);
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
     }
 
     public class RenderOffstage : RenderProxyBox {
-        public RenderOffstage(bool offstage = true,
-            RenderBox child = null) : base(child) {
+        public RenderOffstage(bool offstage = true, RenderBox child = null) : base(child) {
             _offstage = offstage;
         }
 
             }
         }
 
-        public override bool hitTest(BoxHitTestResult result, Offset position) {
+        public override bool hitTest(BoxHitTestResult result, Offset position = null) {
             return !offstage && base.hitTest(result, position: position);
         }
 
 
         public bool absorbing {
             get { return _absorbing; }
-            set { _absorbing = value; }
+            set {
+                if (_absorbing == value)
+                    return;
+                _absorbing = value;
+            }
-        public override bool hitTest(BoxHitTestResult result, Offset position) {
+        public override bool hitTest(BoxHitTestResult result, Offset position = null) {
             return absorbing
                 ? size.contains(position)
                 : base.hitTest(result, position: position);
         }
 
         public override void paint(PaintingContext context, Offset offset) {
-            context.pushLayer(new LeaderLayer(link: link, offset: offset), base.paint, Offset.zero);
+            if (layer == null) {
+                layer = new LeaderLayer(link: link, offset: offset);
+            } else {
+                LeaderLayer leaderLayer = (LeaderLayer)layer;
+                leaderLayer.link = link;
+                leaderLayer.offset = offset;
+            }
+            context.pushLayer(layer, base.paint, Offset.zero);
+            D.assert(layer != null);
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             Offset offset = null,
             RenderBox child = null
         ) : base(child) {
+            D.assert(link != null);
-            this.offset = offset;
+            this.offset = offset?? Offset.zero;
         }
 
         public LayerLink link {
         Offset _offset;
 
         public override void detach() {
-            _layer = null;
+            layer = null;
             base.detach();
         }
 
 
-        new FollowerLayer _layer;
-
+        public FollowerLayer layer { // [!!!] override
+            get {
+                return base.layer as FollowerLayer;
+            }
+            set {
+                if (layer == value)
+                    return;
+                layer = value;
+            }
+        }
+        
-            return _layer?.getLastTransform() ?? Matrix4.identity();
+            return layer?.getLastTransform() ?? Matrix4.identity();
-        public override bool hitTest(BoxHitTestResult result, Offset position) {
+        public override bool hitTest(BoxHitTestResult result, Offset position = null) {
-        protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
+        protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
             return result.addWithPaintTransform(
                 transform: getCurrentTransform(),
                 position: position,
         }
 
         public override void paint(PaintingContext context, Offset offset) {
-            _layer = new FollowerLayer(
-                link: link,
-                showWhenUnlinked: showWhenUnlinked,
-                linkedOffset: this.offset,
-                unlinkedOffset: offset
-            );
-            context.pushLayer(_layer,
+            if (layer == null) {
+                layer = new FollowerLayer(
+                    link: link,
+                    showWhenUnlinked: showWhenUnlinked,
+                    linkedOffset: this.offset,
+                    unlinkedOffset: offset
+                );
+            }
+            else {
+                layer.link = link;
+                layer.showWhenUnlinked = showWhenUnlinked;
+                layer.linkedOffset = this.offset;
+                layer.unlinkedOffset = offset;
+            }
+
+            context.pushLayer(
+                layer,
                 base.paint,
                 Offset.zero,
                 childPaintBounds: Rect.fromLTRB(

com.unity.uiwidgets/Runtime/rendering/proxy_sliver.cs

             RenderSliver sliver = null,
             float opacity = 1.0f
         ) : base( child:sliver) {
-            D.assert(opacity != null && opacity >= 0.0 && opacity <= 1.0);
+            D.assert(opacity >= 0.0 && opacity <= 1.0);
-            child = sliver;
         }
 
 
 
         public float opacity {
             get { return _opacity; }
-            set { 
-                D.assert(value != null);
+            set {
                 D.assert(value >= 0.0 && value <= 1.0);
                 if (_opacity == value) 
                     return;
                 _alpha = ui.Color.getAlphaFromOpacity(_opacity);
                 if (didNeedCompositing != alwaysNeedsCompositing) 
                     markNeedsCompositingBitsUpdate();
-                markNeedsPaint(); 
-                //if (wasVisible != (_alpha != 0) && !alwaysIncludeSemantics) 
-                //    markNeedsSemanticsUpdate();
+                markNeedsPaint();
             }
         }
         float _opacity;
                     return;
                 }
                 D.assert(needsCompositing);
-                var opacity = context.pushOpacity(
+                layer = context.pushOpacity(
-                layer = opacity;
-        /*public override void visitChildrenForSemantics(RenderObject visitor) {
-            visitor = (RenderObjectVisitor)visitor;
-            if (child != null && (_alpha != 0 || alwaysIncludeSemantics))
-              visitor(child);
-        }*/
+
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) { 
             base.debugFillProperties(properties);
             properties.add(new FloatProperty("opacity", opacity));
             RenderSliver sliver = null,
             bool ignoring = true,
             bool? ignoringSemantics = null
-            ):base(child:sliver){
-                child = sliver;
-                D.assert(ignoring != null);
-                _ignoring = ignoring;
+            ) : base(child:sliver){
+            _ignoring = ignoring;
         }
 
 
-                D.assert(value != null);
-                //if (_ignoringSemantics == null || !_ignoringSemantics)
-                //    markNeedsSemanticsUpdate();
             }
         }
         bool _ignoring;
                 crossAxisPosition: crossAxisPosition
               );
         }
-        /*public override void visitChildrenForSemantics(RenderObjectVisitor visitor) {
-            if (child != null && !_effectiveIgnoringSemantics)
-            visitor(child);
-         }*/
+
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<bool>("ignoring", ignoring));
         public RenderSliverOffstage(
             RenderSliver sliver = null,
-            bool offstage = true): base(child:sliver)  {
-              D.assert(offstage != null);
-              _offstage = offstage;
-              child = sliver;
+            bool offstage = true): base(child:sliver) {
+            _offstage = offstage;
-                D.assert(value != null);
                 if (value == _offstage)
                     return;
                 _offstage = value;
                 return;
             context.paintChild(child, offset);
         }
-
-        /*public override void visitChildrenForSemantics(RenderObjectVisitor visitor) {
-            if (offstage)
-              return;
-            base.visitChildrenForSemantics(visitor);
-          }*/ 
+        
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<bool>("offstage", offstage));

com.unity.uiwidgets/Runtime/widgets/animated_size.cs

         public AnimatedSize(
             Key key = null,
             Widget child = null,
-            Alignment alignment = null,
+            AlignmentGeometry alignment = null,
             Curve curve = null,
             TimeSpan? duration = null,
             TimeSpan? reverseDuration = null,
             this.vsync = vsync;
         }
 
-        public readonly Alignment alignment;
+        public readonly AlignmentGeometry alignment;
 
         public readonly Curve curve;
 

com.unity.uiwidgets/Runtime/widgets/app.cs

 
     public class _MediaQueryFromWindow : StatefulWidget {
         public _MediaQueryFromWindow(Key key = null, Widget child = null) : base(key: key) {
+            this.child = child;
         }
         public readonly Widget child;
 

com.unity.uiwidgets/Runtime/widgets/basic.cs

             Widget child = null
         ) : base(key: key) {
             this.child = child;
+            this.start = start;
+            this.top = top;
+            this.end = end;
+            this.bottom = bottom;
+            this.width = width;
         }
 
         public readonly float? start;
             VoidCallback onBuild = null
             ) :base(key: new GlobalObjectKey<State>(renderBox)) {
             D.assert(renderBox != null);
+            this.onBuild = onBuild;
         }
 
       
             PointerUpEventListener onPointerUp = null,
             PointerCancelEventListener onPointerCancel = null,
             PointerSignalEventListener onPointerSignal = null,
-           // PointerScrollEventListener onPointerScroll = null,
-           // PointerDragFromEditorEnterEventListener onPointerDragFromEditorEnter = null,
-           // PointerDragFromEditorHoverEventListener onPointerDragFromEditorHover = null,
-           // PointerDragFromEditorExitEventListener onPointerDragFromEditorExit = null,
-           // PointerDragFromEditorReleaseEventListener onPointerDragFromEditorRelease = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             Widget child = null
         ) : base(key: key) {
             this.onPointerHover = onPointerHover;
             //this.onPointerExit = onPointerExit;
             //this.onPointerEnter = onPointerEnter;
-           // this.onPointerScroll = onPointerScroll;
             this.behavior = behavior;
         }
 

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

             float caretStart;
             float caretEnd;
             if (_isMultiline) {
-                // The caret is vertically centered within the line. Expand the caret's
-                // height so that it spans the line because we're going to ensure that the entire
-                // expanded caret is scrolled into view.
                 float lineHeight = renderEditable.preferredLineHeight;
                 float caretOffset = (lineHeight - caretRect.height) / 2;
                 caretStart = caretRect.top - caretOffset;
                 );
                 _selectionOverlay.handlesVisible = widget.showSelectionHandles;
                 _selectionOverlay.showHandles();
-                /*bool longPress = cause == SelectionChangedCause.longPress;
-                if (cause != SelectionChangedCause.keyboard && (_value.text.isNotEmpty() || longPress)) {
-                    _selectionOverlay.showHandles();
-                }
-                if (longPress || cause == SelectionChangedCause.doubleTap) {
-                    _selectionOverlay.showToolbar();
-                }*/
                 if (widget.onSelectionChanged != null) {
                     widget.onSelectionChanged(selection, cause);
                 }
         public void didChangeAccessibilityFeatures() {}
 
 
+        //_WhitespaceDirectionalityFormatter _whitespaceFormatter;
+
+            //whitespaceFormatter ??= new _WhitespaceDirectionalityFormatter(textDirection: _textDirection);
+
+            bool textChanged = _value?.text != value?.text;
+            bool isRepeatText = value?.text == _lastFormattedUnmodifiedTextEditingValue?.text;
+            bool isRepeatSelection = value?.selection == _lastFormattedUnmodifiedTextEditingValue?.selection; 
+            bool isRepeatComposing = value?.composing == _lastFormattedUnmodifiedTextEditingValue?.composing;
+           
+            if (!isRepeatText && textChanged && widget.inputFormatters != null && widget.inputFormatters.isNotEmpty()) {
+                foreach (TextInputFormatter formatter in widget.inputFormatters) {
+                    value = formatter.formatEditUpdate(_value, value);
+                }
+                //value = _whitespaceFormatter.formatEditUpdate(_value, value);
+                _lastFormattedValue = value;
+            }
+
+            _value = value;
+           
+            if (isRepeatText && isRepeatSelection && isRepeatComposing && textChanged && _lastFormattedValue != null) {
+                _value = _lastFormattedValue;
+            }
+
+          
+            _updateRemoteEditingValueIfNeeded();
+
+            if (textChanged && widget.onChanged != null)
+                widget.onChanged(value.text);
+            _lastFormattedUnmodifiedTextEditingValue = _receivedRemoteTextEditingValue;
+            /*
             var textChanged = _value?.text != value?.text || isIMEInput;
             if (textChanged && widget.inputFormatters != null && widget.inputFormatters.isNotEmpty()) {
                 foreach (var formatter in widget.inputFormatters) {
 
             if (textChanged && widget.onChanged != null) {
                 widget.onChanged(value.text);
-            }
+            }*/
         }
 
         void _onCursorColorTick() {
             );
         }
 
-        // unity keyboard has a preview view with editing function, text selection & cursor function of this widget is disable
-        // in the case
+       
-        /*Offset _getImePos() {
-            if (_hasInputConnection && _textInputConnection.imeRequired()) {
-                var localPos = renderEditable.getLocalRectForCaret(_value.selection.basePos).bottomLeft;
-                return renderEditable.localToGlobal(localPos);
-            }
-
-            return null;
-        }*/
+        
-        /*void _updateImePosIfNeed() {
-            if (!_hasInputConnection || !_textInputConnection.imeRequired()) {
-                return;
-            }
-
-            if (_imePosUpdateScheduled) {
-                return;
-            }
-
-            _imePosUpdateScheduled = true;
-            SchedulerBinding.instance.addPostFrameCallback(_ => {
-                _imePosUpdateScheduled = false;
-                if (!_hasInputConnection) {
-                    return;
-                }
-
-                _textInputConnection.setIMEPos(_getImePos());
-            });
-        }*/
+        
+    
 
     class _Editable : LeafRenderObjectWidget {
         public readonly TextSpan textSpan;

com.unity.uiwidgets/Runtime/widgets/fade_in_image.cs

             Curve fadeInCurve,
             Key key = null
         ) : base(key: key, duration: fadeInDuration + fadeOutDuration) {
-          
-           
+            
             this.target = target;
             this.placeholder = placeholder;
             this.isTargetLoaded = isTargetLoaded;
             FloatTween _placeholderOpacity;
             Animation<float> _targetOpacityAnimation;
             Animation<float> _placeholderOpacityAnimation;
-
-            /*@override
-            void forEachTween(TweenVisitor<dynamic> visitor) {
-                _targetOpacity = visitor(
-                    _targetOpacity,
-                    widget.isTargetLoaded ? 1.0 : 0.0,
-                    (dynamic value) => Tween<double>(begin: value as double),
-                ) as Tween<double>;
-                _placeholderOpacity = visitor(
-                    _placeholderOpacity,
-                    widget.isTargetLoaded ? 0.0 : 1.0,
-                    (dynamic value) => Tween<double>(begin: value as double),
-                ) as Tween<double>;
-            }*/
 
             protected override void forEachTween(TweenVisitor visitor) {
                 _targetOpacity = (FloatTween) visitor.visit(

com.unity.uiwidgets/Runtime/widgets/focus_manager.cs

 
     public class FocusManager : DiagnosticableTreeMixinChangeNotifier{
         public FocusManager() 
-        {
+        { 
             rootScope._manager = this;
             RawKeyboard.instance.addListener(_handleRawKeyEvent);
             GestureBinding.instance.pointerRouter.addGlobalRoute(_handlePointerEvent);

com.unity.uiwidgets/Runtime/widgets/focus_traversal.cs

             FocusTraversalPolicy policy = null,
             Widget child = null
         ) : base(key: key) {
-            policy = policy ?? new ReadingOrderTraversalPolicy();
+            this.policy = policy ?? new ReadingOrderTraversalPolicy();
             this.child = child;
         }
 
             ) {
                 groupNode = marker?.focusNode;
                 policy = marker?.policy ?? defaultPolicy ?? new ReadingOrderTraversalPolicy();
-                members = members ?? new List<FocusNode>();
+                this.members = members ?? new List<FocusNode>();
             }
             public readonly FocusNode groupNode;
             public readonly FocusTraversalPolicy policy;

com.unity.uiwidgets/Runtime/widgets/image_filter.cs

             Key key = null,
             ImageFilter imageFilter = null,
             Widget child = null
-        ) : 
-        base(key: key, child: child) {
+        ) : base(key: key, child: child) {
             D.assert(imageFilter != null);
             this.imageFilter = imageFilter;
         }

com.unity.uiwidgets/Runtime/widgets/navigator.cs

             return other.GetType() == GetType() &&
                    other.key == key;
         }
-
-        //public abstract Route createRoute(BuildContext context);
-
         public override string ToString() {
             return $"{GetType()}(\"{name}\",{key},{arguments})";
         }
         public _RouteEntry(
             Route route,
             _RouteLifecycle initialState
-
         ) {
             D.assert(
                 initialState == _RouteLifecycle.staging ||

com.unity.uiwidgets/Runtime/widgets/scroll_notification.cs

         public ScrollEndNotification(
             ScrollMetrics metrics = null,
             BuildContext context = null,
-            DragEndDetails dragDetails = null,
-            float overscroll = 0,
-            float velocity = 0
-        ) : base(metrics: metrics, context: context) {
+            DragEndDetails dragDetails = null
+            ) : base(metrics: metrics, context: context) {
             this.dragDetails = dragDetails;
         }
 

com.unity.uiwidgets/Runtime/widgets/scroll_simulation.cs

             float friction = 0.015f,
             Tolerance tolerance = null
         ) : base(tolerance: tolerance) {
-            D.assert(_flingVelocityPenetration(0.0f) ==
-                     _initialVelocityPenetration);
+            D.assert(_flingVelocityPenetration(0.0f) == _initialVelocityPenetration);
             this.position = position;
             this.velocity = velocity;
             this.friction = friction;

com.unity.uiwidgets/Runtime/widgets/transitions.cs

 
     public class SliverFadeTransition : SingleChildRenderObjectWidget {
         public SliverFadeTransition(
-            Animation<float> opacity = default,
+            Animation<float> opacity = null,
             Key key = null,
             Widget sliver = null
         ) : base(key: key, child: sliver) {

com.unity.uiwidgets/Runtime/widgets/viewport.cs

             AxisDirection? crossAxisDirection = null,
             ViewportOffset offset = null,
             List<Widget> slivers = null
-        ) : base(key: key, children: slivers) {
-            slivers = slivers ?? new List<Widget>();
+        ) : base(key: key, children: slivers ?? new List<Widget>()) {
             D.assert(offset != null);
             this.axisDirection = axisDirection;
             this.crossAxisDirection = crossAxisDirection;

com.unity.uiwidgets/Runtime/widgets/widget_inspector.cs

             RenderObject target 
         ) {
             D.assert(target != null);
+            this.target = target;
             containerLayer = new _ScreenshotContainerLayer();
         }
 
             ContainerLayer containerLayer = null,
             Rect estimatedBounds = null,
             _ScreenshotData screenshotData = null
-          ) : 
-            base(containerLayer, estimatedBounds) {
+          ) : base(containerLayer, estimatedBounds) {
               _data = screenshotData;
         }
 
         public readonly string tooltip;
         public readonly TextDirection textDirection;
 
-        public _InspectorOverlayRenderState(Rect overlayRect, _TransformedRect selected,
-            List<_TransformedRect> candidates, string tooltip, TextDirection textDirection) {
+        public _InspectorOverlayRenderState(
+            Rect overlayRect, 
+            _TransformedRect selected,
+            List<_TransformedRect> candidates, 
+            string tooltip, 
+            TextDirection textDirection) {
             this.overlayRect = overlayRect;
             this.selected = selected;
             this.candidates = candidates;