Merge branch 'dev_1.17.5' into shiyun/skia

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsExample.cs

         {
             public override Widget build(BuildContext context)
             {
-                return new CupertinoPageScaffold(
-                    child: new Center(
-                        child: new CupertinoButton(
-                            child: new Text(
-                                "THIS IS TAB #"
-                            ),
-                            onPressed: () =>
-                            {
-                                Navigator.of(context).push(
-                                    new CupertinoPageRoute(builder: (contex3) =>
-                                    {
-                                        return
-                                            new CupertinoAlertDemo();
-                                    })
-                                );
-                            }
-                        )
-                        //new Text("hello world!", style: CupertinoTheme.of(context).textTheme.navTitleTextStyle)
-                    )
-                    //backgroundColor: Colors.brown
-                );
+                // return new CupertinoPageScaffold(
+                //     child: new Center(
+                //         child: new CupertinoButton(
+                //             child: new Text(
+                //                 "THIS IS TAB #"
+                //             ),
+                //             onPressed: () =>
+                //             {
+                //                 Navigator.of(context).push(
+                //                     new CupertinoPageRoute(builder: (contex3) =>
+                //                     {
+                //                         return
+                //                             new CupertinoAlertDemo();
+                //                     })
+                //                 );
+                //             }
+                //         )
+                //         //new Text("hello world!", style: CupertinoTheme.of(context).textTheme.navTitleTextStyle)
+                //     )
+                //     //backgroundColor: Colors.brown
+                // );
 
                 List<BottomNavigationBarItem> items = new List<BottomNavigationBarItem>();
                 items.Add(new BottomNavigationBarItem(

com.unity.uiwidgets/Runtime/animation/animation.cs

             get { return status == AnimationStatus.completed; }
         }
 
+        public Animation<U> drive<U>(Animatable<U> child) {
+            D.assert(this is Animation<float>);
+            return child.animate(this as Animation<float>);
+        }
+
         public override string ToString() {
             return $"{foundation_.describeIdentity(this)}({toStringDetails()})";
         }
 
             D.assert(icon != null);
             return icon;
-        }
-
-        public Animation<U> drive<U>(Animatable<U> child) {
-            D.assert(this is Animation<float>);
-            return child.animate(this as Animation<float>);
         }
     }
 }

com.unity.uiwidgets/Runtime/animation/animation_controller.cs

 using System;
+using System.Collections.Generic;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.physics;
 using Unity.UIWidgets.scheduler2;
         AnimationController(
             float value = 0.0f,
             TimeSpan? duration = null,
+            TimeSpan? reverseDuration = null,
             string debugLabel = null,
             TickerProvider vsync = null
         ) {
             _direction = _AnimationDirection.forward;
 
             this.duration = duration;
+            this.reverseDuration = reverseDuration;
             this.debugLabel = debugLabel;
 
             _ticker = vsync.createTicker(_tick);
         public static AnimationController unbounded(
             float value = 0.0f,
             TimeSpan? duration = null,
+            TimeSpan? reverseDuration = null,
-            return new AnimationController(value, duration, debugLabel, vsync);
+            return new AnimationController(value, duration, reverseDuration, debugLabel, vsync);
         }
 
         public readonly float lowerBound;
             D.assert(() => {
                 if (duration == null) {
                     throw new UIWidgetsError(
-                        "AnimationController.forward() called with no default Duration.\n" +
+                        "AnimationController.forward() called with no default duration.\n" +
                         "The \"duration\" property should be set, either in the constructor or later, before " +
                         "calling the forward() function."
                     );
 
         public TickerFuture reverse(float? from = null) {
             D.assert(() => {
-                if (duration == null) {
+                if (duration == null && reverseDuration == null) {
-                        "AnimationController.reverse() called with no default Duration.\n" +
-                        "The \"duration\" property should be set, either in the constructor or later, before " +
+                        "AnimationController.reverse() called with no default duration or reverseDuration.\n" +
+                        "The \"duration\" or \"reverseDuration\" property should be set, either in the constructor or later, before " +
                         "calling the reverse() function."
                     );
                 }
             TimeSpan? simulationDuration = duration;
             if (simulationDuration == null) {
                 D.assert(() => {
-                    if (this.duration == null) {
+                    if ((this.duration == null && _direction == _AnimationDirection.reverse && reverseDuration == null) || 
+                        (this.duration == null && _direction == _AnimationDirection.forward)) {
-                            "AnimationController.animateTo() called with no explicit Duration and no default Duration.\n" +
+                            "AnimationController.animateTo() called with no explicit Duration and no default duration or reverseDuration.\n" +
-                            "\"duration\" property should be set, either in the constructor or later, before " +
+                            "\"duration\" and/or \"reverseDuration\" property should be set, either in the constructor or later, before " +
                             "calling the animateTo() function."
                         );
                     }
                 float range = upperBound - lowerBound;
                 float remainingFraction = range.isFinite() ? (target - _value).abs() / range : 1.0f;
-                simulationDuration = TimeSpan.FromTicks((long) (this.duration.Value.Ticks * remainingFraction));
+                TimeSpan directionDuration = (_direction == _AnimationDirection.reverse && reverseDuration != null)
+                    ? reverseDuration.Value
+                    : this.duration.Value;
+                
+                simulationDuration = TimeSpan.FromTicks((long) (directionDuration.Ticks * remainingFraction));
             }
             else if (target == value) {
                 simulationDuration = TimeSpan.Zero;
 
             D.assert(max >= min);
             D.assert(max <= upperBound && min >= lowerBound);
-            return animateWith(new _RepeatingSimulation(_value, min.Value, max.Value, reverse, period.Value));
+            stop();
+            return _startSimulation(new _RepeatingSimulation(_value, min.Value, max.Value, reverse, period.Value, _directionSetter));
+        }
+
+        void _directionSetter(_AnimationDirection direction) {
+            _direction = direction;
+            _status = (_direction == _AnimationDirection.forward) ? AnimationStatus.forward : AnimationStatus.reverse;
+            _checkStatusChanged();
         }
 
         public TickerFuture fling(float velocity = 1.0f) {
             Simulation simulation = new SpringSimulation(_kFlingSpringDescription, value,
                 target, velocity);
             simulation.tolerance = _kFlingTolerance;
-            return animateWith(simulation);
+            stop();
+            return _startSimulation(simulation);
         }
 
 
                 "AnimationController methods should not be used after calling dispose."
             );
             stop();
+            _direction = _AnimationDirection.forward;
             return _startSimulation(simulation);
         }
 
         public override void dispose() {
             D.assert(() => {
                 if (_ticker == null) {
-                    throw new UIWidgetsError(
-                        "AnimationController.dispose() called more than once.\n" +
-                        "A given " + GetType() + " cannot be disposed more than once.\n" +
-                        "The following " + GetType() + " object was disposed multiple times:\n" +
-                        "  " + this);
+                    throw new UIWidgetsError(new List<DiagnosticsNode>() {
+                        new ErrorSummary("AnimationController.dispose() called more than once."),
+                        new ErrorDescription($"A given {GetType()} cannot be disposed more than once.\n"),
+                        new DiagnosticsProperty<AnimationController>(
+                            $"The following {GetType()} object was disposed multiple times",
+                            this,
+                            style: DiagnosticsTreeStyle.errorProperty)
+                    });
                 }
 
                 return true;
         }
     }
 
+    delegate void _DirectionSetter(_AnimationDirection direction);
+
-        internal _RepeatingSimulation(float initialValue, float min, float max, bool reverse, TimeSpan period) {
+        internal _RepeatingSimulation(float initialValue, float min, float max, bool reverse, TimeSpan period, _DirectionSetter directionSetter) {
             _min = min;
             _max = max;
             _periodInSeconds = (float) period.Ticks / TimeSpan.TicksPerSecond;
+            this.directionSetter = directionSetter;
             D.assert(_periodInSeconds > 0.0f);
             D.assert(_initialT >= 0.0f);
         }
         readonly float _periodInSeconds;
         readonly bool _reverse;
         readonly float _initialT;
+        readonly _DirectionSetter directionSetter;
 
         public override float x(float timeInSeconds) {
             D.assert(timeInSeconds >= 0.0f);
 
             if (_reverse && _isPlayingReverse) {
+                directionSetter(_AnimationDirection.reverse);
+                directionSetter(_AnimationDirection.forward);
                 return MathUtils.lerpFloat(_min, _max, t);
             }
         }

com.unity.uiwidgets/Runtime/animation/curves.cs

 using System;
+using System.Collections.Generic;
+using System.Linq;
+using Random = System.Random;
-    public abstract class Curve {
-        public float transform(float t) {
-            D.assert(t >= 0.0f && t <= 1.0f);
+    public abstract class ParametricCurve<T> {
+        public virtual T transform(float t) {
+            D.assert(t >= 0.0f && t <= 1.0f, () => $"parametric value {t} is outside of [0, 1] range.");
+            return transformInternal(t);
+        }
+        
+        protected virtual T transformInternal(float t) {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString() {
+            return $"{GetType()}";
+        }
+    }
+    
+    public abstract class Curve : ParametricCurve<float> {
+        public override float transform(float t) {
-            return transformInternal(t);
-        }
-
-        protected virtual float transformInternal(float t) {
-            throw new NotImplementedException();
+            return base.transform(t);
-        }
-
-        public override string ToString() {
-            return GetType().ToString();
         }
     }
 
 
         public override string ToString() {
             return $"{GetType()}({a:F2}, {b:F2}, {c:F2}, {d:F2})";
+        }
+    }
+
+    public abstract class Curve2D : ParametricCurve<Offset> {
+        internal IEnumerable<Curve2DSample> generateSamples(
+            float start = 0.0f,
+            float end = 1.0f,
+            float tolerance = 1e-10f) {
+            D.assert(end > start);
+
+            Random rand = new Random(samplingSeed);
+            bool isFlat(Offset p, Offset q, Offset r) {
+                Offset pr = p - r;
+                Offset qr = q - r;
+                float z = pr.dx * qr.dy - qr.dx * pr.dy;
+                return z * z < tolerance;
+            }
+            
+            Curve2DSample first = new Curve2DSample(start, transform(start));
+            Curve2DSample last = new Curve2DSample(end, transform(end));
+            List<Curve2DSample> samples = new List<Curve2DSample>(){first};
+
+            void sample(Curve2DSample p, Curve2DSample q, bool forceSubdivide = false) {
+                float t = p.t + (0.45f + 0.1f * (float)rand.NextDouble() * (q.t - p.t));
+                Curve2DSample r = new Curve2DSample(t, transform(t));
+
+                if (!forceSubdivide && isFlat(p.value, q.value, r.value)) {
+                    samples.Add(q);
+                }
+                else {
+                    sample(p, r);
+                    sample(r, q);
+                }
+            }
+            
+            sample(first, last,
+                forceSubdivide: (first.value.dx - last.value.dx).abs() < tolerance &&
+                                (first.value.dy - last.value.dy).abs() < tolerance);
+
+            return samples;
+        }
+
+        protected virtual int samplingSeed {
+            get { return 0; }
+        }
+
+        public float findInverse(float x) {
+            float start = 0.0f;
+            float end = 1.0f;
+            float mid = 0f;
+
+            float offsetToOrigin(float pos) {
+                return x - transform(pos).dx;
+            }
+
+            const float errorLimit = 1e-6f;
+            int count = 100;
+            float startValue = offsetToOrigin(start);
+            while ((end - start / 2.0f) > errorLimit && count > 0) {
+                mid = (end + start) / 2.0f;
+                float value = offsetToOrigin(mid);
+                if (value.sign() == startValue.sign()) {
+                    start = mid;
+                }
+                else {
+                    end = mid;
+                }
+
+                count--;
+            }
+
+            return mid;
+        }
+    }
+
+    internal class Curve2DSample {
+        public Curve2DSample(float t, Offset value) {
+            this.t = t;
+            this.value = value;
+        }
+        
+        public readonly float t;
+        public readonly Offset value;
+
+        public override string ToString() {
+            return $"[{value.dx:F2}, {value.dy:F2}, {t:F2}]";
+        }
+    }
+
+    class CatmullRomSpline : Curve2D {
+        CatmullRomSpline(
+            List<Offset> controlPoints,
+            float? tension = 0.0f,
+            Offset startHandle = null,
+            Offset endHandle = null
+        ) {
+            D.assert(controlPoints != null);
+            D.assert(tension != null);
+            D.assert(tension <= 1.0f, () => $"tension {tension} must not be greater than 1.0.");
+            D.assert(tension >= 0.0f, () => $"tension {tension} must not be negative.");
+            D.assert(controlPoints.Count > 3, () => "There must be at least four control points to create a CatmullRomSpline.");
+            _controlPoints = controlPoints;
+            _startHandle = startHandle;
+            _endHandle = endHandle;
+            _tension = tension;
+            _cubicSegments = new List<List<Offset>>();
+        }
+        
+        internal CatmullRomSpline(
+            List<Offset> controlPoints,
+            float? tension = 0.0f,
+            Offset startHandle = null,
+            Offset endHandle = null,
+            List<List<Offset>> cubicSegments = null
+        ) {
+            D.assert(cubicSegments != null);
+            _controlPoints = controlPoints;
+            _startHandle = startHandle;
+            _endHandle = endHandle;
+            _tension = tension;
+            _cubicSegments = new List<List<Offset>>();
+        }
+
+        public static CatmullRomSpline precompute(
+            List<Offset> controlPoints,
+            float? tension = 0.0f,
+            Offset startHandle = null,
+            Offset endHandle = null
+        ) {
+            D.assert(controlPoints != null);
+            D.assert(tension != null);
+            D.assert(tension <= 1.0f, () => $"tension {tension} must not be greater than 1.0.");
+            D.assert(tension >= 0.0f, () => $"tension {tension} must not be negative.");
+            D.assert(controlPoints.Count > 3, () => "There must be at least four control points to create a CatmullRomSpline.");
+            return new CatmullRomSpline(
+                controlPoints: null,
+                tension: null,
+                startHandle: null,
+                endHandle: null,
+                cubicSegments: _computeSegments(controlPoints, tension, startHandle: startHandle, endHandle: endHandle)
+            );
+        }
+
+        static List<List<Offset>> _computeSegments(
+            List<Offset> controlPoints,
+            float? tension,
+            Offset startHandle,
+            Offset endHandle) {
+            startHandle = startHandle ?? controlPoints[0] * 2.0f - controlPoints[1];
+            endHandle = endHandle ?? controlPoints.last() * 2.0f - controlPoints[controlPoints.Count - 2];
+
+            List<Offset> allPoints = new List<Offset>();
+            allPoints.Add(startHandle);
+            allPoints.AddRange(controlPoints);
+            allPoints.Add(endHandle);
+            
+            const float alpha = 0.5f;
+            float reverseTension = 1.0f - tension.Value;
+            List<List<Offset>> result = new List<List<Offset>>();
+            for (int i = 0; i < allPoints.Count - 3; ++i) {
+                List<Offset> curve = new List<Offset>{allPoints[i], allPoints[i + 1], allPoints[i + 2], allPoints[i + 3]};
+                Offset diffCurve10 = curve[1] - curve[0];
+                Offset diffCurve21 = curve[2] - curve[1];
+                Offset diffCurve32 = curve[3] - curve[2];
+                float t01 = Mathf.Pow(diffCurve10.distance, alpha);
+                float t12 = Mathf.Pow(diffCurve21.distance, alpha);
+                float t23 = Mathf.Pow(diffCurve32.distance, alpha);
+                
+                Offset m1 = (diffCurve21 + (diffCurve10 / t01 - (curve[2] - curve[0]) / (t01 + t12)) * t12) * reverseTension;
+                Offset m2 = (diffCurve21 + (diffCurve32 / t23 - (curve[3] - curve[1]) / (t12 + t23)) * t12) * reverseTension;
+                Offset sumM12 = m1 + m2;
+
+                List<Offset> segment = new List<Offset> {
+                    diffCurve21 * -2.0f + sumM12,
+                    diffCurve21 * 3.0f - m1 - sumM12,
+                    m1,
+                    curve[1]
+                };
+                result.Add(segment);
+            }
+
+            return result;
+        }
+
+        readonly List<List<Offset>> _cubicSegments;
+
+        readonly List<Offset> _controlPoints;
+        readonly Offset _startHandle;
+        readonly Offset _endHandle;
+        readonly float? _tension;
+
+        void _initializeIfNeeded() {
+            if (_cubicSegments.isNotEmpty()) {
+                return;
+            }
+            _cubicSegments.AddRange(_computeSegments(_controlPoints, _tension, startHandle: _startHandle, endHandle: _endHandle));
+        }
+
+        protected override int samplingSeed {
+            get {
+                _initializeIfNeeded();
+                Offset seedPoint = _cubicSegments[0][1];
+                return ((seedPoint.dx + seedPoint.dy) * 10000).round();
+            }
+        }
+
+        protected override Offset transformInternal(float t) {
+            _initializeIfNeeded();
+            float length = _cubicSegments.Count;
+            float position;
+            float localT;
+            int index;
+            
+            if (t < 1.0f) {
+                position = t * length;
+                localT = position - position.floor();
+                index = position.floor();
+            } else {
+                position = length;
+                localT = 1.0f;
+                index = _cubicSegments.Count - 1;
+            }
+            List<Offset> cubicControlPoints = _cubicSegments[index];
+            float localT2 = localT * localT;
+            return cubicControlPoints[0] * localT2 * localT
+                   + cubicControlPoints[1] * localT2
+                   + cubicControlPoints[2] * localT
+                   + cubicControlPoints[3];
+        }
+    }
+
+    public class CatmullRomCurve : Curve {
+        public CatmullRomCurve(
+            List<Offset> controlPoints,
+            float? tension = 0.0f) {
+            D.assert(tension != null);
+            
+            this.controlPoints = controlPoints;
+            this.tension = tension;
+            
+            D.assert(() => {
+                _debugAssertReasons.Clear();
+                return validateControlPoints(controlPoints,
+                    tension: tension,
+                    reasons: _debugAssertReasons);
+            }, () => $"control points {controlPoints} could not be validated:\n  {string.Join("\n ", _debugAssertReasons)}");
+            _precomputedSamples = new List<Curve2DSample>();
+        }
+        
+        internal CatmullRomCurve(
+            List<Offset> controlPoints,
+            float? tension = 0.0f,
+            List<Curve2DSample> precomputedSamples = null) {
+            D.assert(precomputedSamples != null);
+            D.assert(tension != null);
+            
+            this.controlPoints = controlPoints;
+            this.tension = tension;
+            
+            D.assert(() => {
+                _debugAssertReasons.Clear();
+                return validateControlPoints(controlPoints,
+                    tension: tension,
+                    reasons: _debugAssertReasons);
+            }, () => $"control points {controlPoints} could not be validated:\n  {string.Join("\n ", _debugAssertReasons)}");
+
+            _precomputedSamples = precomputedSamples;
+        }
+
+        public static CatmullRomCurve precompute(
+            List<Offset> controlPoints, float? tension = 0.0f) {
+            return new CatmullRomCurve(
+                controlPoints,
+                tension,
+                _computeSamples(controlPoints, tension));
+        }
+
+        static List<Curve2DSample> _computeSamples(List<Offset> controlPoints, float? tension) {
+            List<Offset> _controlPoints = new List<Offset>();
+            _controlPoints.Add(Offset.zero);
+            _controlPoints.AddRange(controlPoints);
+            _controlPoints.Add(new Offset(1.0f, 1.0f));
+            
+            return CatmullRomSpline.precompute(_controlPoints, tension: tension).generateSamples(
+                start: 0.0f, end: 1.0f, tolerance: 1e-12f).ToList();
+        }
+        
+        static readonly List<String> _debugAssertReasons = new List<String>();
+
+        readonly List<Curve2DSample> _precomputedSamples;
+
+        public readonly List<Offset> controlPoints;
+
+        public readonly float? tension;
+
+        static bool validateControlPoints(
+            List<Offset> controlPoints,
+            float? tension = 0.0f,
+            List<string> reasons = null) {
+            D.assert(tension != null);
+            if (controlPoints == null) {
+                D.assert(() => {
+                    reasons?.Add("Supplied control points cannot be null");
+                    return true;
+                });
+                return false;
+            }
+
+            if (controlPoints.Count < 2) {
+                D.assert(() => {
+                    reasons?.Add("There must be at least two points supplied to create a valid curve.");
+                    return true;
+                });
+                return false;
+            }
+
+            List<Offset> _controlPoints = new List<Offset>();
+            _controlPoints.AddRange(controlPoints);
+            
+            _controlPoints.Insert(0, Offset.zero);
+            _controlPoints.Add(new Offset(1.0f, 1.0f));
+            
+            Offset startHandle = _controlPoints[0] * 2.0f - _controlPoints[1];
+            Offset endHandle = _controlPoints.last() * 2.0f - _controlPoints[_controlPoints.Count - 2];
+            _controlPoints.Insert(0, startHandle);
+            _controlPoints.Add(endHandle);
+
+            float lastX = -float.PositiveInfinity;
+            for (int i = 0; i < _controlPoints.Count; ++i) {
+                if (i > 1 &&
+                    i < _controlPoints.Count - 2 &&
+                    (_controlPoints[i].dx <= 0.0f || _controlPoints[i].dx >= 1.0f)) {
+                    D.assert(() => {
+                        reasons?.Add("Control points must have X values between 0.0 and 1.0, exclusive. " +
+                        $"Point {i} has an x value ({_controlPoints[i].dx}) which is outside the range.");
+                        return true;
+                    });
+                    return false;
+                }
+                if (_controlPoints[i].dx <= lastX) {
+                    D.assert(() => {
+                        reasons?.Add("Each X coordinate must be greater than the preceding X coordinate " +
+                        $"(i.e. must be monotonically increasing in X). Point {i} has an x value of " + 
+                        $"{_controlPoints[i].dx}, which is not greater than {lastX}");
+                        return true;
+                    });
+                    return false;
+                }
+                lastX = _controlPoints[i].dx;
+            }
+            
+            bool success = true;
+            lastX = -float.PositiveInfinity;
+            const float tolerance = 1e-3f;
+            CatmullRomSpline testSpline = new CatmullRomSpline(_controlPoints, tension: tension);
+            float start = testSpline.findInverse(0.0f);
+            float end = testSpline.findInverse(1.0f);
+            IEnumerable<Curve2DSample> samplePoints = testSpline.generateSamples(start: start, end: end);
+
+            if (samplePoints.First().value.dy.abs() > tolerance ||
+                (1.0f - samplePoints.Last().value.dy).abs() > tolerance) {
+                bool bail = true;
+                success = false;
+                D.assert(() => {
+                    reasons?.Add($"The curve has more than one Y value at X = {samplePoints.First().value.dx}. " +
+                    "Try moving some control points further away from this value of X, or increasing " + 
+                    "the tension.");
+                    bail = reasons == null;
+                    return true;
+                });
+                if (bail) {
+                    return false;
+                }
+            }
+            foreach (Curve2DSample sample in samplePoints) {
+                Offset point = sample.value;
+                float t = sample.t;
+                float x = point.dx;
+                if (t >= start && t <= end && (x < -1e-3f || x > 1.0f + 1e-3f)) {
+                    bool bail = true;
+                    success = false;
+                    D.assert(() => {
+                        reasons?.Add($"The resulting curve has an X value ({x}) which is outside " +
+                        "the range [0.0, 1.0], inclusive.");
+                        bail = reasons == null;
+                        return true;
+                    });
+                    if (bail) {
+                        return false;
+                    }
+                }
+                if (x < lastX) {
+                    bool bail = true;
+                    success = false;
+                    D.assert(() => {
+                        reasons?.Add($"The curve has more than one Y value at x = {x}. Try moving " +
+                        "some control points further apart in X, or increasing the tension.");
+                        bail = reasons == null;
+                        return true;
+                    });
+                    if (bail) {
+                        return false;
+                    }
+                }
+                lastX = x;
+            }
+            return success;
+        }
+
+        protected override float transformInternal(float t) {
+            if (_precomputedSamples.isEmpty()) {
+                // Compute the samples now if we were constructed lazily.
+                _precomputedSamples.AddRange(_computeSamples(controlPoints, tension));
+            }
+            int start = 0;
+            int end = _precomputedSamples.Count - 1;
+            int mid;
+            Offset value;
+            Offset startValue = _precomputedSamples[start].value;
+            Offset endValue = _precomputedSamples[end].value;
+            while (end - start > 1) {
+                mid = (end + start) / 2;
+                value = _precomputedSamples[mid].value;
+                if (t >= value.dx) {
+                    start = mid;
+                    startValue = value;
+                } else {
+                    end = mid;
+                    endValue = value;
+                }
+            }
+            float t2 = (t - startValue.dx) / (endValue.dx - startValue.dx);
+            return Mathf.Lerp(startValue.dy, endValue.dy, t2);
         }
     }
 

com.unity.uiwidgets/Runtime/animation/listener_helpers.mixin.gen.cs

 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.animation {
+
+ 
-        int _listenerCounter = 0;
+        int _listenerCounter;
 
         protected void didRegisterListener() {
             D.assert(_listenerCounter >= 0);
     }
 
 
+
+ 
     public abstract class AnimationEagerListenerMixinAnimation<T> : Animation<T> {
         protected void didRegisterListener() {
         }
     }
 
 
-    public abstract class
-        AnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T> : AnimationLazyListenerMixinAnimation<T> {
+
+ 
+    public abstract class AnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T> : AnimationLazyListenerMixinAnimation<T> {
         readonly ObserverList<VoidCallback> _listeners = new ObserverList<VoidCallback>();
 
         public override void addListener(VoidCallback listener) {
         public void notifyListeners() {
             var localListeners = new List<VoidCallback>(_listeners);
             foreach (VoidCallback listener in localListeners) {
+                InformationCollector collector = null;
+                D.assert(() => {
+                      IEnumerable<DiagnosticsNode> infoCollector() {
+                          yield return new DiagnosticsProperty<AnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T>>(
+                              "The " + GetType() + " notifying listeners was:",
+                              this,
+                              style: DiagnosticsTreeStyle.errorProperty
+                          );
+                      }
+                      collector = infoCollector;
+                      return true;
+                });
-                }
-                catch (Exception exception) {
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<
-                            AnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T>>(
-                            "The " + GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
-
+                } catch (Exception exception) {
-                        informationCollector: infoCollector
+                        informationCollector: collector
                     ));
                 }
             }
 
-    public abstract class
-        AnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T> : AnimationEagerListenerMixinAnimation<T> {
+ 
+    public abstract class AnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T> : AnimationEagerListenerMixinAnimation<T> {
         readonly ObserverList<VoidCallback> _listeners = new ObserverList<VoidCallback>();
 
         public override void addListener(VoidCallback listener) {
         public void notifyListeners() {
             var localListeners = new List<VoidCallback>(_listeners);
             foreach (VoidCallback listener in localListeners) {
+                InformationCollector collector = null;
+                D.assert(() => {
+                      IEnumerable<DiagnosticsNode> infoCollector() {
+                          yield return new DiagnosticsProperty<AnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T>>(
+                              "The " + GetType() + " notifying listeners was:",
+                              this,
+                              style: DiagnosticsTreeStyle.errorProperty
+                          );
+                      }
+                      collector = infoCollector;
+                      return true;
+                });
-                }
-                catch (Exception exception) {
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<
-                            AnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T>>(
-                            "The " + GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
-
+                } catch (Exception exception) {
-                        informationCollector: infoCollector
+                        informationCollector: collector
                     ));
                 }
             }
 
-    public abstract class
-        AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T> :
-            AnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T> {
+
+ 
+    public abstract class AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T> : AnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T> {
         readonly ObserverList<AnimationStatusListener> _statusListeners = new ObserverList<AnimationStatusListener>();
 
         public override void addStatusListener(AnimationStatusListener listener) {
                     if (_statusListeners.Contains(listener)) {
                         listener(status);
                     }
-                }
-                catch (Exception exception) {
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<
-                            AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationLazyListenerMixinAnimation
-                            <T>>(
-                            "The " + GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
-
+                } catch (Exception exception) {
+                    InformationCollector collector = null;
+                    D.assert(() => {
+                        IEnumerable<DiagnosticsNode> infoCollector() {
+                            yield return new DiagnosticsProperty<AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationLazyListenerMixinAnimation<T>>(
+                                "The " + GetType() + " notifying status listeners was:",
+                                this,
+                                style: DiagnosticsTreeStyle.errorProperty
+                            );
+                        }
+                        
+                        collector = infoCollector;
+                        return true;
+                    });
+                
-                        informationCollector: infoCollector
+                        informationCollector: collector
                     ));
                 }
             }
 
-    public abstract class
-        AnimationLocalStatusListenersMixinAnimationLazyListenerMixinAnimation<T> : AnimationLazyListenerMixinAnimation<T
-        > {
+ 
+    public abstract class AnimationLocalStatusListenersMixinAnimationLazyListenerMixinAnimation<T> : AnimationLazyListenerMixinAnimation<T> {
         readonly ObserverList<AnimationStatusListener> _statusListeners = new ObserverList<AnimationStatusListener>();
 
         public override void addStatusListener(AnimationStatusListener listener) {
                     if (_statusListeners.Contains(listener)) {
                         listener(status);
                     }
-                }
-                catch (Exception exception) {
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<
-                            AnimationLocalStatusListenersMixinAnimationLazyListenerMixinAnimation<T>>(
-                            "The " + GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
-
+                } catch (Exception exception) {
+                    InformationCollector collector = null;
+                    D.assert(() => {
+                        IEnumerable<DiagnosticsNode> infoCollector() {
+                            yield return new DiagnosticsProperty<AnimationLocalStatusListenersMixinAnimationLazyListenerMixinAnimation<T>>(
+                                "The " + GetType() + " notifying status listeners was:",
+                                this,
+                                style: DiagnosticsTreeStyle.errorProperty
+                            );
+                        }
+                        
+                        collector = infoCollector;
+                        return true;
+                    });
+                
-                        informationCollector: infoCollector
+                        informationCollector: collector
                     ));
                 }
             }
 
-    public abstract class
-        AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T> :
-            AnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T> {
+ 
+    public abstract class AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T> : AnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T> {
         readonly ObserverList<AnimationStatusListener> _statusListeners = new ObserverList<AnimationStatusListener>();
 
         public override void addStatusListener(AnimationStatusListener listener) {
                     if (_statusListeners.Contains(listener)) {
                         listener(status);
                     }
-                }
-                catch (Exception exception) {
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<
-                            AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationEagerListenerMixinAnimation
-                            <T>>(
-                            "The " + GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
-
+                } catch (Exception exception) {
+                    InformationCollector collector = null;
+                    D.assert(() => {
+                        IEnumerable<DiagnosticsNode> infoCollector() {
+                            yield return new DiagnosticsProperty<AnimationLocalStatusListenersMixinAnimationLocalListenersMixinAnimationEagerListenerMixinAnimation<T>>(
+                                "The " + GetType() + " notifying status listeners was:",
+                                this,
+                                style: DiagnosticsTreeStyle.errorProperty
+                            );
+                        }
+                        
+                        collector = infoCollector;
+                        return true;
+                    });
+                
-                        informationCollector: infoCollector
+                        informationCollector: collector
+
+
 }

com.unity.uiwidgets/Runtime/animation/listener_helpers.mixin.njk

         public void notifyListeners() {
             var localListeners = new List<VoidCallback>(this._listeners);
             foreach (VoidCallback listener in localListeners) {
+                InformationCollector collector = null;
+                D.assert(() => {
+                      IEnumerable<DiagnosticsNode> infoCollector() {
+                          yield return new DiagnosticsProperty<AnimationLocalListenersMixin{{with | safe}}>(
+                              "The " + this.GetType() + " notifying listeners was:",
+                              this,
+                              style: DiagnosticsTreeStyle.errorProperty
+                          );
+                      }
+                      collector = infoCollector;
+                      return true;
+                });
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<AnimationLocalListenersMixin{{with | safe}}>(
-                            "The " + this.GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
-                    
-                        informationCollector: infoCollector
+                        informationCollector: collector
                     ));
                 }
             }
                         listener(status);
                     }
                 } catch (Exception exception) {
-                    IEnumerable<DiagnosticsNode> infoCollector() {
-                        yield return new DiagnosticsProperty<AnimationLocalStatusListenersMixin{{with | safe}}>(
-                            "The " + this.GetType() + " notifying listeners was:",
-                            this,
-                            style: DiagnosticsTreeStyle.errorProperty
-                        );
-                    }
+                    InformationCollector collector = null;
+                    D.assert(() => {
+                        IEnumerable<DiagnosticsNode> infoCollector() {
+                            yield return new DiagnosticsProperty<AnimationLocalStatusListenersMixin{{with | safe}}>(
+                                "The " + this.GetType() + " notifying status listeners was:",
+                                this,
+                                style: DiagnosticsTreeStyle.errorProperty
+                            );
+                        }
+                        
+                        collector = infoCollector;
+                        return true;
+                    });
-                        informationCollector: infoCollector
+                        informationCollector: collector
                     ));
                 }
             }

com.unity.uiwidgets/Runtime/animation/tween.cs

             return lerp(t);
         }
 
-
-        /*public override T evaluate(Animation<float> animation) {
-            float t = animation.value;
-            if (t == 0.0) {
-                return begin;
-            }
-
-            if (t == 1.0) {
-                return end;
-            }
-
-            return lerp(t);
-        }*/
-
         public override string ToString() {
             return $"{GetType()}({begin} \u2192 {end})";
         }

com.unity.uiwidgets/Runtime/animation/tween_sequence.cs

               if (_intervals[index].contains(t))
                 return _evaluateAt(t, index);
             }
-            D.assert(false, ()=>$"TweenSequence.evaluate() could not find an interval for {t}");
+            D.assert(false, ()=> $"TweenSequence.evaluate() could not find an interval for {t}");
             return default(T);
         }
         public override string ToString(){

com.unity.uiwidgets/Runtime/engine2/UIWidgetsPanel.cs

         public TextFont[] fonts;
 
         static object fontsToObject(TextFont[] textFont) {
+            if (textFont == null || textFont.Length == 0) {
+                return null;
+            }
             var result = new object[textFont.Length];
             for (int i = 0; i < textFont.Length; i++) {
                 var font = new Dictionary<string, object>();

com.unity.uiwidgets/Runtime/gestures/converter.cs

 using UnityEngine;
 
 namespace Unity.UIWidgets.gestures {
-    class _PointerState {
-        public _PointerState(Offset lastPosition) {
-            this.lastPosition = lastPosition ?? Offset.zero;
-        }
-
-        public int pointer {
-            get { return _pointer; }
-        }
-
-        int _pointer;
-
-        // pointers 0 ~ 9 are preserved for special unique inputs
-        static int _pointerCount = 10;
-
-        // special pointer id:
-        // mouse scroll
-        const int scrollPointer = 5;
-
-        public void initScrollPointer() {
-            _pointer = scrollPointer;
-        }
-
-        public void startNewPointer() {
-            _pointerCount += 1;
-            _pointer = _pointerCount;
-        }
-
-        public bool down {
-            get { return _down; }
-        }
-
-        bool _down = false;
-
-        public void setDown() {
-            D.assert(!_down);
-            _down = true;
-        }
-
-        public void setUp() {
-            D.assert(_down);
-            _down = false;
-        }
-
-        public Offset lastPosition;
-
-        public Offset deltaTo(Offset to) {
-            return to - lastPosition;
-        }
-
-        public override string ToString() {
-            return $"_PointerState(pointer: {pointer}, down: {down}, lastPosition: {lastPosition})";
-        }
-
+    public partial class gesture_ {
+                case PointerDeviceKind.mouse:
+                    return buttons;
-                    return buttons;
+                case PointerDeviceKind.stylus:
+                case PointerDeviceKind.invertedStylus:
+                    return buttons | kPrimaryButton;
-                    return buttons;
+                    // We have no information about the device but we know we never want
+                    // buttons to be 0 when the pointer is down.
+                    return buttons == 0 ? kPrimaryButton : buttons;
             }
         }
     }
-        static readonly Dictionary<int, _PointerState> _pointers = new Dictionary<int, _PointerState>();
-
-        static void clearPointers() {
-            _pointers.Clear();
-        }
-
-        static _PointerState _ensureStateForPointer(PointerData datum, Offset position) {
-            return _pointers.putIfAbsent(
-                datum.device,
-                () => new _PointerState(position));
-        }
-
+                Offset delta = new Offset(datum.physicalDeltaX, datum.physicalDeltaY) / devicePixelRatio;
                 var radiusMinor = _toLogicalPixels(datum.radiusMinor, devicePixelRatio);
                 var radiusMajor = _toLogicalPixels(datum.radiusMajor, devicePixelRatio);
                 var radiusMin = _toLogicalPixels(datum.radiusMin, devicePixelRatio);
-
-                switch (datum.change) {
-                    case PointerChange.add: {
-                        D.assert(!_pointers.ContainsKey(datum.device));
-                        
-                        _PointerState state = _ensureStateForPointer(datum, position);
-                        D.assert(state.lastPosition == position);
-                        yield return new PointerAddedEvent(
-                            timeStamp: timeStamp,
-                            kind: kind,
-                            device: datum.device,
-                            position: position,
-                            obscured: datum.obscured,
-                            pressureMin: datum.pressureMin,
-                            pressureMax: datum.pressureMax,
-                            distance: datum.distance,
-                            distanceMax: datum.distanceMax,
-                            radiusMin: radiusMin,
-                            radiusMax: radiusMax,
-                            orientation: datum.orientation,
-                            tilt: datum.tilt
-                        );
-                        break;
-                    }
-
-                    case PointerChange.down: {
-                        _PointerState state = _ensureStateForPointer(datum, position);
-                        if (state.down) {
+                if (datum.signalKind == null || datum.signalKind == ui.PointerSignalKind.none) {
+                    switch (datum.change) {
+                        case PointerChange.add: {
+                            yield return new PointerAddedEvent(
+                                timeStamp: timeStamp,
+                                kind: kind,
+                                device: datum.device,
+                                position: position,
+                                obscured: datum.obscured,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distance: datum.distance,
+                                distanceMax: datum.distanceMax,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax,
+                                orientation: datum.orientation,
+                                tilt: datum.tilt
+                            );
-                        if (state.lastPosition != position) {
-                            // a hover event to be here.
-                            state.lastPosition = position;
-                        }
-
-                        state.startNewPointer();
-                        state.setDown();
-                        yield return new PointerDownEvent(
-                            timeStamp: timeStamp,
-                            pointer: state.pointer,
-                            kind: kind,
-                            device: datum.device,
-                            position: position
-                        );
-                    }
-                        break;
-                    case PointerChange.move: {
-                        bool alreadyAdded = _pointers.ContainsKey(datum.device);
-                        if (!alreadyAdded) {
+                        case PointerChange.hover: {
+                            yield return new PointerHoverEvent(
+                                timeStamp: timeStamp,
+                                kind: kind,
+                                device: datum.device,
+                                position: position,
+                                delta: delta,
+                                buttons: datum.buttons,
+                                obscured: datum.obscured,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distance: datum.distance,
+                                distanceMax: datum.distanceMax,
+                                size: datum.size,
+                                radiusMajor: radiusMajor,
+                                radiusMinor: radiusMinor,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax,
+                                orientation: datum.orientation,
+                                tilt: datum.tilt,
+                                synthesized: datum.synthesized
+                            );
-
-                        D.assert(_pointers.ContainsKey(datum.device));
-
-                        _PointerState state = _pointers[datum.device];
-                        if (!state.down) {
-                            break;
+                        case PointerChange.down: {
+                            yield return new PointerDownEvent(
+                                timeStamp: timeStamp,
+                                pointer: datum.pointerIdentifier,
+                                kind: kind,
+                                device: datum.device,
+                                position: position,
+                                buttons: gesture_._synthesiseDownButtons(datum.buttons, kind),
+                                obscured: datum.obscured,
+                                pressure: datum.pressure,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distanceMax: datum.distanceMax,
+                                size: datum.size,
+                                radiusMajor: radiusMajor,
+                                radiusMinor: radiusMinor,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax,
+                                orientation: datum.orientation,
+                                tilt: datum.tilt
+                            );
-
-                        D.assert(state.down);
-
-                        Offset offset = position - state.lastPosition;
-                        state.lastPosition = position;
-                        yield return new PointerMoveEvent(
-                            timeStamp: timeStamp,
-                            pointer: state.pointer,
-                            kind: kind,
-                            device: datum.device,
-                            position: position,
-                            delta: offset
-                        );
-                    }
-                        break;
-
-                    case PointerChange.hover: {
-                        yield return new PointerHoverEvent(
-                            timeStamp: timeStamp,
-                            kind: kind,
-                            device: datum.device,
-                            position: position
-                        );
-                        break;
-                    }
-
-                    // case PointerChange.scroll: {
-                    //     var _scrollData = (ScrollData) datum;
-                    //     _PointerState state = _ensureStateForPointer(datum, position);
-                    //     state.initScrollPointer();
-                    //
-                    //     if (state.lastPosition != position) {
-                    //         state.lastPosition = position;
-                    //     }
-                    //
-                    //     Offset scrollDelta = new Offset(_scrollData.scrollX, _scrollData.scrollY) / devicePixelRatio;
-                    //     yield return new PointerScrollEvent(
-                    //         timeStamp: timeStamp,
-                    //         pointer: state.pointer,
-                    //         kind: kind,
-                    //         device: _scrollData.device,
-                    //         position: position,
-                    //         scrollDelta: scrollDelta
-                    //     );
-                    //     break;
-                    // }
-
-                    case PointerChange.up:
-                    case PointerChange.cancel: {
-                        _PointerState state = _pointers.getOrDefault(datum.device);
-                        if (state == null || !state.down) {
-                        }
-                        D.assert(state.down);
-                        if (position != state.lastPosition) {
-                            Offset offset = position - state.lastPosition;
-                            state.lastPosition = position;
+                        case PointerChange.move: {
-                                pointer: state.pointer,
+                                pointer: datum.pointerIdentifier,
-                                delta: offset,
-                                synthesized: true
+                                delta: delta,
+                                buttons: gesture_._synthesiseDownButtons(datum.buttons, kind),
+                                obscured: datum.obscured,
+                                pressure: datum.pressure,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distanceMax: datum.distanceMax,
+                                size: datum.size,
+                                radiusMajor: radiusMajor,
+                                radiusMinor: radiusMinor,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax,
+                                orientation: datum.orientation,
+                                tilt: datum.tilt,
+                                platformData: datum.platformData,
+                                synthesized: datum.synthesized
-
-                        D.assert(position == state.lastPosition);
-                        state.setUp();
-                        if (datum.change == PointerChange.up) {
+                            break;
+                        case PointerChange.up:
-                                pointer: state.pointer,
+                                pointer: datum.pointerIdentifier,
-                                position: position
+                                position: position,
+                                buttons: datum.buttons,
+                                obscured: datum.obscured,
+                                pressure: datum.pressure,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distance: datum.distance,
+                                distanceMax: datum.distanceMax,
+                                size: datum.size,
+                                radiusMajor: radiusMajor,
+                                radiusMinor: radiusMinor,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax,
+                                orientation: datum.orientation,
+                                tilt: datum.tilt
-                        }
-                        else {
+                            break;
+                        case PointerChange.cancel: {
-                                pointer: state.pointer,
+                                pointer: datum.pointerIdentifier,
-                                position: position
+                                position: position,
+                                buttons: datum.buttons,
+                                obscured: datum.obscured,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distance: datum.distance,
+                                distanceMax: datum.distanceMax,
+                                size: datum.size,
+                                radiusMajor: radiusMajor,
+                                radiusMinor: radiusMinor,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax,
+                                orientation: datum.orientation,
+                                tilt: datum.tilt
-                    }
-                        break;
-                    case PointerChange.remove: {
-                        D.assert(_pointers.ContainsKey(datum.device));
-                        
-                        _PointerState state = _pointers[datum.device];
-                        if (state.down) {
-                            yield return new PointerCancelEvent(
+                            break;
+                        case ui.PointerChange.remove:
+                            yield return new PointerRemovedEvent(
-                                pointer: state.pointer,
-                                position: position
+                                position: position,
+                                obscured: datum.obscured,
+                                pressureMin: datum.pressureMin,
+                                pressureMax: datum.pressureMax,
+                                distanceMax: datum.distanceMax,
+                                radiusMin: radiusMin,
+                                radiusMax: radiusMax
-                        }
-
-                        if (position != state.lastPosition) {
-                            yield return new PointerHoverEvent(
+                            break;
+                    }
+                }
+                else {
+                    switch (datum.signalKind) {
+                        case ui.PointerSignalKind.scroll:
+                            Offset scrollDelta =
+                                new Offset(datum.scrollDeltaX, datum.scrollDeltaY) / devicePixelRatio;
+                            yield return new PointerScrollEvent(
-                                position: position
+                                position: position,
+                                scrollDelta: scrollDelta
-                        }
-
-                        _pointers.Remove(datum.device);
-                        yield return new PointerRemovedEvent(
-                            timeStamp: timeStamp,
-                            kind: kind,
-                            device: datum.device,
-                            position: position
-                            );
-                        break;
+                            break;
+                        case ui.PointerSignalKind.none:
+                            D.assert(false); // This branch should already have 'none' filtered out.
+                            break;
+                        case ui.PointerSignalKind.unknown:
+                            // Ignore unknown signals.
+                            break;
-#if UNITY_EDITOR
-                    // case PointerChange.dragFromEditorMove: {
-                    //     _PointerState state = _ensureStateForPointer(datum, position);
-                    //     state.startNewPointer();
-                    //     yield return new PointerDragFromEditorHoverEvent(
-                    //         timeStamp: timeStamp,
-                    //         pointer: state.pointer,
-                    //         kind: kind,
-                    //         device: datum.device,
-                    //         position: position
-                    //     );
-                    // }
-                    //     break;
-                    // case PointerChange.dragFromEditorRelease: {
-                    //     _PointerState state = _ensureStateForPointer(datum, position);
-                    //     state.startNewPointer();
-                    //     yield return new PointerDragFromEditorReleaseEvent(
-                    //         timeStamp: timeStamp,
-                    //         pointer: state.pointer,
-                    //         kind: kind,
-                    //         device: datum.device,
-                    //         position: position
-                    //     );
-                    // }
-                    //     break;
-#endif
                 }
             }
         }

com.unity.uiwidgets/Runtime/gestures/events.cs

 using Object = UnityEngine.Object;
 
 namespace Unity.UIWidgets.gestures {
+    public partial class gesture_ {
+        public const int kPrimaryButton = 0x01;
+
+        public const int kSecondaryButton = 0x02;
+
+        public const int kPrimaryMouseButton = kPrimaryButton;
+
+        public const int kSecondaryMouseButton = kSecondaryButton;
+
+        public const int kStylusContact = kPrimaryButton;
+
+        public const int kPrimaryStylusButton = kSecondaryButton;
+
+        public const int kMiddleMouseButton = 0x04;
+
+        public const int kSecondaryStylusButton = 0x04;
+
+        public const int kBackMouseButton = 0x08;
+
+        public const int kForwardMouseButton = 0x10;
+
+        public const int kTouchContact = kPrimaryButton;
+
+        public static int kMaxUnsignedSMI {
+            get {
+                Debug.LogError("Update this for io and web");
+                return -1;
+            }
+        }
+
+        public int nthMouseButton(int number) => (kPrimaryMouseButton << (number - 1)) & kMaxUnsignedSMI;
+
+        public int nthStylusButton(int number) => (kPrimaryStylusButton << (number - 1)) & kMaxUnsignedSMI;
+
+        public int smallestButton(int buttons) => buttons & (-buttons);
+
+        public bool isSingleButton(int buttons) => buttons != 0 && (smallestButton(buttons) == buttons);
+    }
+
     public abstract class PointerEvent : Diagnosticable {
         public PointerEvent(
             TimeSpan timeStamp,
             Offset position = null,
             Offset localPosition = null,
             bool obscured = false,
-            float pressure = 0.0f,
             float pressureMin = 1.0f,
             float pressureMax = 1.0f,
             float distance = 0.0f,
             position: position,
             localPosition: localPosition,
             obscured: obscured,
-            pressure: pressure,
+            pressure: 0,
             pressureMin: pressureMin,
             pressureMax: pressureMax,
             distance: distance,
             Offset position = null,
             Offset localPosition = null,
             bool obscured = false,
-            float pressure = 0.0f,
             float pressureMin = 1.0f,
             float pressureMax = 1.0f,
             float distanceMax = 0.0f,
             localPosition: localPosition,
             device: device,
             obscured: obscured,
-            pressure: pressure,
             pressureMin: pressureMin,
             pressureMax: pressureMax,
             distanceMax: distanceMax,
             Offset localDelta = null,
             int buttons = 0,
             bool obscured = false,
-            float pressure = 0.0f,
             float pressureMin = 1.0f,
             float pressureMax = 1.0f,
             float distance = 0.0f,
             localDelta: localDelta,
             buttons: buttons,
             obscured: obscured,
-            pressure: pressure,
+            pressure: 0,
             pressureMin: pressureMin,
             pressureMax: pressureMax,
             size: size,
             Offset localDelta = null,
             int buttons = 0,
             bool obscured = false,
-            float pressure = 0.0f,
             float pressureMin = 1.0f,
             float pressureMax = 1.0f,
             float distance = 0.0f,
             buttons: buttons,
             down: down,
             obscured: obscured,
-            pressure: pressure,
+            pressure: 0,
             pressureMin: pressureMin,
             pressureMax: pressureMax,
             size: size,
                 buttons: hover?.buttons ?? 0,
                 down: hover?.down ?? false,
                 obscured: hover?.obscured ?? false,
-                pressure: hover?.pressure ?? 0.0f,
                 pressureMin: hover?.pressureMin ?? 1.0f,
                 pressureMax: hover?.pressureMax ?? 1.0f,
                 distance: hover?.distance ?? 0.0f,
             Offset localDelta = null,
             int buttons = 0,
             bool obscured = false,
-            float pressure = 0.0f,
             float pressureMin = 1.0f,
             float pressureMax = 1.0f,
             float distance = 0.0f,
             buttons: buttons,
             down: down,
             obscured: obscured,
-            pressure: pressure,
+            pressure: 0,
             pressureMin: pressureMin,
             pressureMax: pressureMax,
             size: size,
                 buttons: hover?.buttons ?? 0,
                 down: hover?.down ?? false,
                 obscured: hover?.obscured ?? false,
-                pressure: hover?.pressure ?? 0.0f,
                 pressureMin: hover?.pressureMin ?? 1.0f,
                 pressureMax: hover?.pressureMax ?? 1.0f,
                 distance: hover?.distance ?? 0.0f,
             int device = 0,
             Offset position = null,
             Offset localPosition = null,
-            int buttons = 0,
+            int buttons = gesture_.kPrimaryButton,
             bool obscured = false,
             float pressure = 0.0f,
             float pressureMin = 1.0f,
             Offset localPosition = null,
             Offset delta = null,
             Offset localDelta = null,
-            int buttons = 0,
+            int buttons = gesture_.kPrimaryButton,
             bool obscured = false,
             float pressure = 0.0f,
             float pressureMin = 1.0f,
             float radiusMax = 0.0f,
             float orientation = 0.0f,
             float tilt = 0.0f,
-            int platformdData = 0,
+            int platformData = 0,
             bool synthesized = false,
             Matrix4 transform = null,
             PointerMoveEvent original = null
             radiusMax: radiusMax,
             orientation: orientation,
             tilt: tilt,
-            platformData: platformdData,
+            platformData: platformData,
             synthesized: synthesized,
             transform: transform,
             original: original) {
                 radiusMax: radiusMax,
                 orientation: orientation,
                 tilt: tilt,
-                // platformData: platformData,
+                platformData: platformData,
                 synthesized: synthesized,
                 transform: transform,
                 original: original as PointerMoveEvent ?? this
 
     public class PointerScrollEvent : PointerSignalEvent {
         public PointerScrollEvent(
-            TimeSpan timeStamp,
-            int pointer,
+            TimeSpan? timeStamp = null,
             PointerDeviceKind kind = PointerDeviceKind.mouse,
             int device = 0,
             Offset position = null,
             PointerScrollEvent original = null)
             : base(
-                timeStamp,
+                timeStamp ?? TimeSpan.Zero,
-                pointer: pointer,
                 device: device,
                 position: position,
                 localPosition: localPosition,
             if (transform == null || transform == this.transform) {
                 return this;
             }
+
-                pointer: pointer,
                 kind: kind,
                 device: device,
                 position: position,
             int device = 0,
             Offset position = null,
             Offset localPosition = null,
-            Object[] objectReferences = null, 
+            Object[] objectReferences = null,
             Matrix4 transform = null,
             PointerDragFromEditorReleaseEvent original = null
         ) : base(

com.unity.uiwidgets/Runtime/gestures/multitap.cs

 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.gestures {
-    public delegate void GestureDoubleTapCallback(DoubleTapDetails details);
+    public delegate void GestureDoubleTapCallback();
 
     public delegate void GestureMultiTapDownCallback(int pointer, TapDownDetails details);
 
             TimeSpan doubleTapMinTime,
             GestureArenaEntry entry = null
         ) {
+            D.assert(evt != null);
+            initialButtons = evt.buttons;
             _doubleTapMinTimeCountdown = new _CountdownZoned(duration: doubleTapMinTime);
             this.entry = entry;
         }
         internal readonly Offset _initialGlobalPosition;
+        internal readonly int initialButtons;
         internal readonly _CountdownZoned _doubleTapMinTimeCountdown;
 
         bool _isTrackingPointer = false;
         public bool hasElapsedMinTime() {
             return _doubleTapMinTimeCountdown.timeout;
         }
+
+        public bool hasSameButton(PointerDownEvent evt) {
+            return evt.buttons == initialButtons;
+        }
     }
 
 
         }
 
         public GestureDoubleTapCallback onDoubleTap;
+
+        protected override bool isPointerAllowed(PointerDownEvent evt) {
+            if (_firstTap == null) {
+                switch (evt.buttons) {
+                    case gesture_.kPrimaryButton:
+                        if (onDoubleTap == null)
+                            return false;
+                        break;
+                    default:
+                        return false;
+                }
+            }
+
+            return base.isPointerAllowed(evt as PointerDownEvent);
+        }
 
         Timer _doubleTapTimer;
         _TapTracker _firstTap;
-            if (_firstTap != null &&
-                !_firstTap.isWithinGlobalTolerance(evt, Constants.kDoubleTapSlop)) {
-                return;
+            if (_firstTap != null) {
+                if (!_firstTap.isWithinGlobalTolerance(evt, Constants.kDoubleTapSlop)) {
+                    // Ignore out-of-bounds second taps.
+                    return;
+                }
+                else if (!_firstTap.hasElapsedMinTime() ||
+                         !_firstTap.hasSameButton(evt as PointerDownEvent)) {
+                    // Restart when the second tap is too close to the first, or when buttons
+                    // mismatch.
+                    _reset();
+                    _trackFirstTap(evt);
+                    return;
+                }
+            _trackFirstTap(evt);
+        }
+
+        void _trackFirstTap(PointerEvent evt) {
-                evt: evt,
+                evt: evt as PointerDownEvent,
                 entry: GestureBinding.instance.gestureArena.add(evt.pointer, this),
                 doubleTapMinTime: Constants.kDoubleTapMinTime
             );
         }
 
         void _registerSecondTap(_TapTracker tracker) {
-            var initialPosition = tracker._initialGlobalPosition;
-            if (onDoubleTap != null) {
-                invokeCallback<object>("onDoubleTap", () => {
-                    onDoubleTap(new DoubleTapDetails(initialPosition));
-                    return null;
-                });
-            }
+            _checkUp(tracker.initialButtons);
 
             _reset();
         }
             if (_doubleTapTimer != null) {
                 _doubleTapTimer.cancel();
                 _doubleTapTimer = null;
+            }
+        }
+
+        void _checkUp(int buttons) {
+            D.assert(buttons == gesture_.kPrimaryButton);
+            if (onDoubleTap != null) {
+                invokeCallback("onDoubleTap",() => onDoubleTap);
             }
         }
 
             );
             if (onTapDown != null) {
                 invokeCallback<object>("onTapDown", () => {
-                    onTapDown(evt.pointer, new TapDownDetails(
-                        globalPosition: evt.position,
+                    onTapDown(evt.pointer, new TapDownDetails(globalPosition: evt.position,
-                        kind: evt.kind));
+                        kind: evt.kind
+                    ));
                     return null;
                 });
             }
             if (onTapUp != null) {
                 invokeCallback<object>("onTapUp",
                     () => {
-                        onTapUp(pointer, new TapUpDetails(globalPosition: position.global, localPosition: position.local));
+                        onTapUp(pointer, new TapUpDetails(
+                            localPosition: position.local,
+                            globalPosition: position.global
+                        ));
                         return null;
                     });
             }
                     () => {
                         onLongTapDown(pointer, new TapDownDetails(
                             globalPosition: lastPosition.global,
-                            localPosition: lastPosition.local));
+                            localPosition: lastPosition.local
+                        ));
                         return null;
                     });
             }
 
         public override string debugDescription {
             get { return "multitap"; }
+        }
+    }
+
+    delegate bool _RouteEntryPredicate(_RouteEntry entry);
+
+    class _RouteEntry {
+        public _RouteEntry(
+            PointerRoute route,
+            Matrix4 transform
+        ) {
+            this.route = route;
+            this.transform = transform;
+        }
+
+        public readonly PointerRoute route;
+        public readonly Matrix4 transform;
+
+        static _RouteEntryPredicate isRoutePredicate(PointerRoute route) {
+            return (_RouteEntry entry) => entry.route == route;
         }
     }
 }

com.unity.uiwidgets/Runtime/gestures/pointer_router.cs

     public delegate void PointerRoute(PointerEvent evt);
 
     public class PointerRouter {
-        readonly Dictionary<int, Dictionary<PointerRoute, Matrix4>> _routeMap = new Dictionary<int, Dictionary<PointerRoute, Matrix4>>();
+        readonly Dictionary<int, Dictionary<PointerRoute, Matrix4>> _routeMap =
+            new Dictionary<int, Dictionary<PointerRoute, Matrix4>>();
-                pointer, 
+                pointer,
-        
+
         public void removeRoute(int pointer, PointerRoute route) {
             D.assert(_routeMap.ContainsKey(pointer));
             var routes = _routeMap[pointer];
             }
         }
-        
+
-        
+
         public void removeGlobalRoute(PointerRoute route) {
             D.assert(_globalRoutes.ContainsKey(route));
             _globalRoutes.Remove(route);
                     new Dictionary<PointerRoute, Matrix4>(routes)
                 );
             }
+
-        
+
         public void _dispatchEventToRoutes(
             PointerEvent evt,
             Dictionary<PointerRoute, Matrix4> referenceRoutes,

com.unity.uiwidgets/Runtime/gestures/pointer_signal_resolver.cs

     public delegate void PointerSignalResolvedCallback(PointerSignalEvent evt);
 
     public class PointerSignalResolver {
+        public bool _isSameEvent(PointerSignalEvent event1, PointerSignalEvent event2) {
+            return (event1.original ?? event1) == (event2.original ?? event2);
+        }
+    
         PointerSignalResolvedCallback _firstRegisteredCallback;
 
         PointerSignalEvent _currentEvent;
             D.assert(callback != null);
-            D.assert(_currentEvent == null || _currentEvent == evt);
+            D.assert(_currentEvent == null || _isSameEvent(_currentEvent, evt));
             if (_firstRegisteredCallback != null) {
                 return;
             }
                 return;
             }
 
-            D.assert((_currentEvent.original ?? _currentEvent) == evt);
+            D.assert(_isSameEvent(_currentEvent, evt));
             try {
                 _firstRegisteredCallback(_currentEvent);
             }

com.unity.uiwidgets/Runtime/gestures/recognizer.cs

         protected virtual void resolvePointer(int pointer, GestureDisposition disposition) {
             GestureArenaEntry entry = _entries[pointer];
             if (entry != null) {
-            entry.resolve(disposition);
-            _entries.Remove(pointer);
+                entry.resolve(disposition);
+                _entries.Remove(pointer);
             }
         }
 

com.unity.uiwidgets/Runtime/gestures/scale.cs

     }
 
     public class ScaleStartDetails {
-        public ScaleStartDetails(Offset focalPoint = null) {
+        public ScaleStartDetails(
+            Offset focalPoint = null,
+            Offset localFocalPoint = null
+        ) {
+            this.localFocalPoint = localFocalPoint ?? this.focalPoint;
+        public readonly Offset localFocalPoint;
-            return $"ScaleStartDetails(focalPoint: {focalPoint}";
+            return $"ScaleStartDetails(focalPoint: {focalPoint}, localFocalPoint: {localFocalPoint})";
         }
     }
 
             Offset focalPoint = null,
+            Offset localFocalPoint = null,
             float scale = 1.0f,
             float horizontalScale = 1.0f,
             float verticalScale = 1.0f,
+            localFocalPoint = localFocalPoint ?? this.focalPoint;
 
             D.assert(scale >= 0.0f);
             D.assert(horizontalScale >= 0.0f);
         }
 
         public readonly Offset focalPoint;
+        public readonly Offset localFocalPoint;
 
         public readonly float scale;
 
 
         public override string ToString() {
             return
-                $"ScaleUpdateDetails(focalPoint: {focalPoint}, scale: {scale}, horizontalScale: {horizontalScale}, verticalScale: {verticalScale}, rotation: {rotation}";
+                $"ScaleUpdateDetails(focalPoint: {focalPoint}, localFocalPoint: {localFocalPoint}, scale: {scale}, horizontalScale: {horizontalScale}, verticalScale: {verticalScale}, rotation: {rotation}";
         }
     }
 
 
     public class ScaleGestureRecognizer : OneSequenceGestureRecognizer {
         public ScaleGestureRecognizer(object debugOwner, PointerDeviceKind? kind = null) : base(debugOwner: debugOwner,
-            kind: kind) { }
+            kind: kind) {
+        }
 
         public GestureScaleStartCallback onStart;
 
 
         _ScaleState _state = _ScaleState.ready;
+
+        Matrix4 _lastTransform;
 
         Offset _initialFocalPoint;
         Offset _currentFocalPoint;
         }
 
         public override void addAllowedPointer(PointerDownEvent evt) {
-            startTrackingPointer(evt.pointer);
+            startTrackingPointer(evt.pointer, evt.transform);
             _velocityTrackers[evt.pointer] = new VelocityTracker();
             if (_state == _ScaleState.ready) {
                 _state = _ScaleState.possible;
                 }
 
                 _pointerLocations[evt.pointer] = evt.position;
-                shouldStartIfAccepted = true;
+                shouldStartIfAccepted = true;      
+                _lastTransform = evt.transform;
             }
             else if (evt is PointerDownEvent) {
                 _pointerLocations[evt.pointer] = evt.position;
+                _lastTransform = evt.transform;
+                _lastTransform = evt.transform;
             }
 
             _updateLines();
                         horizontalScale: _horizontalScaleFactor,
                         verticalScale: _verticalScaleFactor,
                         focalPoint: _currentFocalPoint,
+                        localFocalPoint: PointerEvent.transformPosition(_lastTransform, _currentFocalPoint),
                         rotation: _computeRotationFactor()
                     ));
                     return null;
             D.assert(_state == _ScaleState.started);
             if (onStart != null) {
                 invokeCallback<object>("onStart", () => {
-                    onStart(new ScaleStartDetails(focalPoint: _currentFocalPoint));
+                    onStart(new ScaleStartDetails(
+                        focalPoint: _currentFocalPoint,
+                        localFocalPoint: PointerEvent.transformPosition(_lastTransform, _currentFocalPoint)
+                    ));
                     return null;
                 });
             }

com.unity.uiwidgets/Runtime/gestures/tap.cs

 
         bool _sentTapDown = false;
         bool _wonArenaForPrimaryPointer = false;
+        OffsetPair _finalPosition;
 
         PointerDownEvent _down;
         PointerUpEvent _up;
         protected override void handlePrimaryPointer(PointerEvent evt) {
             if (evt is PointerUpEvent) {
                 _up = (PointerUpEvent) evt;
+                _finalPosition = new OffsetPair(global: evt.position, local: evt.localPosition);
+
                 _checkUp();
             } else if (evt is PointerCancelEvent) {
                 resolve(GestureDisposition.rejected);

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

         }
 
         public TextHeightBehavior textHeightBehavior {
-            get { return textHeightBehavior; }
+            get { return _textHeightBehavior; }
             set {
                 if (_textHeightBehavior == value)
                     return;

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

             _doubleTap = new DoubleTapGestureRecognizer(this);
             _tap.onTapDown = _handleTapDown;
             _tap.onTap = _handleTap;
-            _doubleTap.onDoubleTap = _handleDoubleTap;
             _longPress = new LongPressGestureRecognizer(debugOwner: this);
             _longPress.onLongPress = _handleLongPress;
 

com.unity.uiwidgets/Runtime/services/asset_bundle.cs

                     throw new UIWidgetsError($"Unable to load asset: {key}");
 
                 if (data.Length < 10 * 1024) {
-                    // 10KB takes about 3ms to parse on a Pixel 2 XL.
-                    // See: https://github.com/dart-lang/sdk/issues/31954
                     return Encoding.UTF8.GetString(data);
                 }
 
                 yield return www.SendWebRequest();
 
                 if (www.isNetworkError || www.isHttpError) {
-                    completer.completeError(new Exception($"Failed to load from url \"{url}\": {www.error}"));
+                    completer.completeError(new UIWidgetsError(new List<DiagnosticsNode>() {
+                        new ErrorSummary($"Unable to load asset: {key}"),
+                        new StringProperty("HTTP status code", www.error)
+                    }));
                     yield break;
                 }
 

com.unity.uiwidgets/Runtime/services/binding.cs

 
             _defaultBinaryMessenger = createBinaryMessenger();
             window.onPlatformMessage = defaultBinaryMessenger.handlePlatformMessage;
-            //initLicenses();
             //SystemChannels.system.setMessageHandler(handleSystemMessage);
         }
 
             services_.rootBundle.evict(asset);
         }
     }
-
 
     class _DefaultBinaryMessenger : BinaryMessenger {
         internal _DefaultBinaryMessenger() {

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

         ) :
         base(key: key, child: child) {
             D.assert(behavior != null);
+            this.onPointerDown = onPointerDown;
+            this.onPointerMove = onPointerMove;
+            this.onPointerUp = onPointerUp;
+            this.onPointerCancel = onPointerCancel;
+            this.onPointerSignal = onPointerSignal;
+            this.behavior = behavior;
         }
 
         public readonly PointerDownEventListener onPointerDown;

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

                     fontFamily: style.fontFamily,
                     fontSize: style.fontSize,
                     fontWeight: style.fontWeight,
-                    textDirection: _textDirection,
+                    textDirection: _textDirection.Value,
                     textAlign: widget.textAlign
                 );
                 _textInputConnection.setEditingState(localValue);

com.unity.uiwidgets/Runtime/services/text_editing.cs

 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.service {
-    // public class TextRange : IEquatable<TextRange> {
-    //     public readonly int start;
-    //     public readonly int end;
-    //
-    //     public static TextRange collapsed(int offset) {
-    //         D.assert(offset >= -1);
-    //         return new TextRange(offset, offset);
-    //     }
-    //
-    //     public static readonly TextRange empty = new TextRange(-1, -1);
-    //
-    //     public TextRange(int start, int end) {
-    //         D.assert(start >= -1);
-    //         D.assert(end >= -1);
-    //         this.start = start;
-    //         this.end = end;
-    //     }
-    //
-    //     public bool isValid {
-    //         get { return start >= 0 && end >= 0; }
-    //     }
-    //
-    //     public bool isCollapsed {
-    //         get { return start == end; }
-    //     }
-    //
-    //     public bool isNormalized {
-    //         get { return start <= end; }
-    //     }
-    //
-    //     public string textBefore(string text) {
-    //         D.assert(isNormalized);
-    //         return text.Substring(0, start);
-    //     }
-    //
-    //     public string textAfter(string text) {
-    //         D.assert(isNormalized);
-    //         return text.Substring(end);
-    //     }
-    //
-    //     public string textInside(string text) {
-    //         D.assert(isNormalized);
-    //         return text.Substring(start, end - start);
-    //     }
-    //
-    //     public bool Equals(TextRange other) {
-    //         if (ReferenceEquals(null, other)) {
-    //             return false;
-    //         }
-    //
-    //         if (ReferenceEquals(this, other)) {
-    //             return true;
-    //         }
-    //
-    //         return start == other.start && end == other.end;
-    //     }
-    //
-    //     public override bool Equals(object obj) {
-    //         if (ReferenceEquals(null, obj)) {
-    //             return false;
-    //         }
-    //
-    //         if (ReferenceEquals(this, obj)) {
-    //             return true;
-    //         }
-    //
-    //         if (obj.GetType() != GetType()) {
-    //             return false;
-    //         }
-    //
-    //         return Equals((TextRange) obj);
-    //     }
-    //
-    //     public override int GetHashCode() {
-    //         unchecked {
-    //             return (start * 397) ^ end;
-    //         }
-    //     }
-    //
-    //     public static bool operator ==(TextRange left, TextRange right) {
-    //         return Equals(left, right);
-    //     }
-    //
-    //     public static bool operator !=(TextRange left, TextRange right) {
-    //         return !Equals(left, right);
-    //     }
-    //
-    //     public override string ToString() {
-    //         return $"TextRange Start: {start}, End: {end}";
-    //     }
-    // }
-
     public class TextSelection : TextRange, IEquatable<TextSelection> {
         public readonly int baseOffset;
         public readonly int extentOffset;

com.unity.uiwidgets/Runtime/services/text_formatter.cs

 
         public readonly int? maxLength;
 
+        internal static TextEditingValue truncate(TextEditingValue value, int maxLength) {
+            TextSelection newSelection = value.selection.copyWith(
+                baseOffset: Mathf.Min(value.selection.start, maxLength),
+                extentOffset: Mathf.Min(value.selection.end, maxLength));
+            string truncated = value.text.Substring(0, maxLength);
+            return new TextEditingValue(
+                text: truncated,
+                selection: newSelection,
+                composing: TextRange.empty
+            );
+        }
+
         public override TextEditingValue formatEditUpdate(TextEditingValue oldValue, TextEditingValue newValue) {
             if (maxLength != null && maxLength > 0 && newValue.text.Length > maxLength) {
                 if (Input.compositionString.Length > 0) {
-                TextSelection newSelection = newValue.selection.copyWith(
-                    baseOffset: Mathf.Min(newValue.selection.start, maxLength.Value),
-                    extentOffset: Mathf.Min(newValue.selection.end, maxLength.Value)
-                );
-                
-                string truncated = newValue.text.Substring(0, maxLength.Value);
-                return new TextEditingValue(
-                    text: truncated,
-                    selection: newSelection,
-                    composing: TextRange.empty
-                );
+                if (oldValue.text.Length == maxLength.Value) {
+                    return oldValue;
+                }
+
+                return truncate(newValue, maxLength.Value);
             }
 
             return newValue;

com.unity.uiwidgets/Runtime/services/text_input.cs

 using UnityEngine;
 
 namespace Unity.UIWidgets.service {
-    public enum FloatingCursorDragState {
-        Start,
-        Update,
-
-        End
+    public enum SmartDashesType {
+        disabled,
+        enabled
-
-
-    public class RawFloatingCursorPoint {
-        public RawFloatingCursorPoint(
-            Offset offset = null,
-            FloatingCursorDragState? state = null
-        ) {
-            D.assert(state != null);
-            D.assert(state != FloatingCursorDragState.Update || offset != null);
-            //D.assert(state == FloatingCursorDragState.Update ? offset != null : true);
-            this.offset = offset;
-            this.state = state;
-        }
-
-        public readonly Offset offset;
-
-        public readonly FloatingCursorDragState? state;
+    public enum SmartQuotesType {
+        disabled,
+        enabled
-
+    
     public class TextInputType : IEquatable<TextInputType> {
         public readonly int index;
         public readonly bool? signed;
         }
 
         public static readonly TextInputType text = new TextInputType(0);
+        
         public static readonly TextInputType multiline = new TextInputType(1);
 
         public static readonly TextInputType number = numberWithOptions();
 
         public static readonly TextInputType url = new TextInputType(6);
 
+        public static readonly TextInputType visiblePassword = new TextInputType(7);
+
+        public static readonly List<TextInputType> values = new List<TextInputType> {
+            text, multiline, number, phone, datetime, emailAddress, url, visiblePassword
+        };
+
-            "text", "multiline", "number", "phone", "datetime", "emailAddress", "url"
+            "text", "multiline", "number", "phone", "datetime", "emailAddress", "url", "visiblePassword"
         };
 
         public JSONNode toJson() {
             return $"{GetType().FullName}(name: {_name}, signed: {signed}, decimal: {decimalNum})";
         }
     }
+    
+    public enum TextInputAction {
+        none,
+        unspecified,
+        done,
+        go,
+        search,
+        send,
+        next,
+        previous,
+        continueAction,
+        join,
+        route,
+        emergencyCall,
+        newline
+    }
+    
+       
+    public enum TextCapitalization {
+        words,
+        sentences,
+        characters,
+        none
+    }
+    public class TextInputConfiguration {
+        public TextInputConfiguration(
+            TextInputType inputType = null,
+            bool obscureText = false, 
+            bool autocorrect = true, 
+            SmartDashesType? smartDashesType = null,
+            SmartQuotesType? smartQuotesType = null,
+            bool enableSuggestions = true,
+            string actionLabel = null,
+            TextInputAction inputAction = TextInputAction.done,
+            ui.Brightness keyboardAppearance = ui.Brightness.light,
+            TextCapitalization textCapitalization = TextCapitalization.none,
+            bool unityTouchKeyboard = false
+            ) {
+            D.assert(inputType != null);
+            this.smartDashesType =
+                smartDashesType ?? (obscureText ? SmartDashesType.disabled : SmartDashesType.enabled);
+            this.smartQuotesType =
+                smartQuotesType ?? (obscureText ? SmartQuotesType.disabled : SmartQuotesType.enabled);
+            this.inputType = inputType ?? TextInputType.text;
+            this.obscureText = obscureText;
+            this.autocorrect = autocorrect;
+            this.enableSuggestions = enableSuggestions;
+            this.actionLabel = actionLabel;
+            this.inputAction = inputAction;
+            this.textCapitalization = textCapitalization;
+            this.keyboardAppearance = keyboardAppearance;
+            this.unityTouchKeyboard = unityTouchKeyboard;
+        }
+        
+        public readonly TextInputType inputType;
+        public readonly bool obscureText;
+        public readonly bool autocorrect;
+        public readonly SmartDashesType smartDashesType;
+        public readonly SmartQuotesType smartQuotesType;
+        public readonly bool enableSuggestions;
+        public readonly string actionLabel;
+        public readonly TextInputAction inputAction;
+        public readonly TextCapitalization textCapitalization;
+        public readonly ui.Brightness keyboardAppearance;
+        
+        public readonly bool unityTouchKeyboard;
+
+        public JSONNode toJson() {
+            var json = new JSONObject();
+            json["inputType"] = inputType.toJson();
+            json["obscureText"] = obscureText;
+            json["autocorrect"] = autocorrect;
+            json["smartDashesType"] = smartDashesType.ToString();
+            json["smartQuotesType"] = smartQuotesType.ToString();
+            json["enableSuggestions"] = enableSuggestions;
+            json["actionLabel"] = actionLabel;
+            json["inputAction"] = inputAction.ToString();
+            json["unityTouchKeyboard"] = unityTouchKeyboard;
+            json["textCapitalization"] = textCapitalization.ToString();
+            json["keyboardAppearance"] = keyboardAppearance.ToString();
+            return json;
+        }
+    }
+    
     static partial class TextInputUtils {
         internal static TextAffinity? _toTextAffinity(string affinity) {
             switch (affinity) {
                     return FloatingCursorDragState.End;
             }
 
-            throw new UIWidgetsError($"Unknown text cursor action: {state}");
+            throw new UIWidgetsError(new List<DiagnosticsNode>() {new ErrorSummary($"Unknown text cursor action: {state}")});
         }
 
         public static RawFloatingCursorPoint _toTextPoint(FloatingCursorDragState state,
         }
     }
 
+    
+    public enum FloatingCursorDragState {
+        Start,
+        Update,
+        End
+    }
+
+    public class RawFloatingCursorPoint {
+        public RawFloatingCursorPoint( 
+            Offset offset = null,
+            FloatingCursorDragState? state = null
+        ) {
+            D.assert(state != null);
+            D.assert(state != FloatingCursorDragState.Update || offset != null);
+            this.offset = offset;
+            this.state = state;
+        }
+
+        public readonly Offset offset;
+
+        public readonly FloatingCursorDragState? state;
+    }
+
-        
-        public readonly string text;
-        public readonly TextSelection selection;
-        public readonly TextRange composing;
+        static JSONNode defaultBoolNode = new JSONBool(false);
 
         public TextEditingValue(
             string text = "",
             D.assert(text != null);
             D.assert(selection != null);
-            D.assert(composing != null);
             this.text = text;
             this.composing = composing ?? TextRange.empty;
 
                 this.selection = selection.copyWith(start, end);
             }
             else {
-                this.selection = TextSelection.collapsed(-1);
+                this.selection = selection ?? TextSelection.collapsed(-1);
-        public static TextEditingValue fromJSON(JSONObject json) {
+        public static TextEditingValue fromJSON(JSONNode json) {
             TextAffinity? affinity =
                 TextInputUtils._toTextAffinity(json["selectionAffinity"].Value);
             return new TextEditingValue(
                     extentOffset: json.GetValueOrDefault("selectionExtent", defaultIndexNode).AsInt,
                     affinity: affinity != null ? affinity.Value : TextAffinity.downstream,
-                    isDirectional: json["selectionIsDirectional"].AsBool
+                    isDirectional: json.GetValueOrDefault("selectionIsDirectional", defaultBoolNode).AsBool
                 ),
                 composing: new TextRange(
                     start: json.GetValueOrDefault("composingBase", defaultIndexNode).AsInt,
             json["composingExtent"] = composing.end;
             return json;
         }
+        
+        public readonly string text;
+        public readonly TextSelection selection;
+        public readonly TextRange composing;
+        
+        public static readonly TextEditingValue empty = new TextEditingValue();
 
         public TextEditingValue copyWith(
             string text = null,
-                text ?? this.text, 
-                selection ?? this.selection, 
-                composing ?? this.composing
+                text: text ?? this.text, 
+                selection: selection ?? this.selection, 
+                composing: composing ?? this.composing
+        //unity-specific
         public TextEditingValue insert(string text) {
             string newText;
             TextSelection newSelection;
             );
         }
 
+        //unity-specific
         public TextEditingValue deleteSelection(bool backDelete = true) {
             if (selection.isCollapsed) {
                 if (backDelete) {
             }
         }
 
+        //unity-specific
+        //unity-specific
+        //unity-specific
+        //unity-specific
+        //unity-specific
         public TextEditingValue moveExtent(int move) {
             int offset = selection.extentOffset + move;
             offset = Mathf.Max(0, offset);
 
+        //unity-specific
         public TextEditingValue moveSelection(int move) {
             int offset = selection.baseOffset + move;
             offset = Mathf.Max(0, offset);
 
+        //unity-specific
         public TextEditingValue compose(string composeText) {
             D.assert(!string.IsNullOrEmpty(composeText));
             var composeStart = composing == TextRange.empty ? selection.start : composing.start;
             );
         }
 
+        //unity-specific
         public TextEditingValue clearCompose() {
             if (composing == TextRange.empty) {
                 return this;
             );
         }
 
-        public static readonly TextEditingValue empty = new TextEditingValue();
-
         public bool Equals(TextEditingValue other) {
             if (ReferenceEquals(null, other)) {
                 return false;
         public override string ToString() {
             return $"Text: {text}, Selection: {selection}, Composing: {composing}";
         }
-
-        public static TextEditingValue fromJSON(JSONNode encoded) {
-            return new TextEditingValue(
-                text: encoded["text"] ,
-                selection: new TextSelection(
-                    baseOffset: encoded.GetValueOrDefault("selectionBase", defaultIndexNode).AsInt,
-                    extentOffset: encoded.GetValueOrDefault("selectionExtent", defaultIndexNode).AsInt,
-                    affinity: TextInputUtils._toTextAffinity(encoded["selectionAffinity"] ) ?? TextAffinity.downstream,
-                    isDirectional: encoded["selectionIsDirectional"]  ?? false
-                ),
-                composing: new TextRange(
-                    start: encoded.GetValueOrDefault("composingBase", defaultIndexNode).AsInt,
-                    end: encoded.GetValueOrDefault("composingExtent", defaultIndexNode).AsInt
-                )
-            );
-        }
-
-        
     }
 
     public interface TextSelectionDelegate {
         void performAction(TextInputAction action);
 
         void updateFloatingCursor(RawFloatingCursorPoint point);
-
-        RawInputKeyResponse globalInputKeyHandler(RawKeyEvent evt);
-
+        
-
-    }
-
-    public enum TextInputAction {
-        none,
-        unspecified,
-        done,
-        go,
-        search,
-        send,
-        next,
-        previous,
-        continueAction,
-        join,
-        route,
-        emergencyCall,
-        newline
-    }
-
-    public enum TextCapitalization {
-        words,
-        sentences,
-        characters,
-        none
-    }
-
-    public class TextInputConfiguration {
-        public TextInputConfiguration(
-            TextInputType inputType = null,
-            bool obscureText = false, 
-            bool autocorrect = true, 
-            //SmartDashesType smartDashesType,
-            //SmartQuotesType smartQuotesType,
-            bool enableSuggestions = true,
-            string actionLabel = null,
-            TextInputAction inputAction = TextInputAction.done,
-            ui.Brightness keyboardAppearance = ui.Brightness.light,
-            TextCapitalization textCapitalization = TextCapitalization.none,
-            bool unityTouchKeyboard = false
-            ) {
-            D.assert(inputType != null);
-            D.assert(obscureText != null);
-            //smartDashesType = smartDashesType ?? (obscureText ? SmartDashesType.disabled : SmartDashesType.enabled),
-            //smartQuotesType = smartQuotesType ?? (obscureText ? SmartQuotesType.disabled : SmartQuotesType.enabled),
-            D.assert(autocorrect != null);
-            D.assert(enableSuggestions != null);
-            D.assert(keyboardAppearance != null);
-            D.assert(inputAction != null);
-            D.assert(textCapitalization != null);
-            this.inputType = inputType ?? TextInputType.text;
-            this.obscureText = obscureText;
-            this.autocorrect = autocorrect;
-            this.enableSuggestions = enableSuggestions;
-            this.actionLabel = actionLabel;
-            this.inputAction = inputAction;
-            this.textCapitalization = textCapitalization;
-            this.keyboardAppearance = keyboardAppearance;
-            this.unityTouchKeyboard = unityTouchKeyboard;
-        }
-        public readonly TextInputAction inputAction;
-        public readonly TextInputType inputType;
-        public readonly string actionLabel;
-        public readonly bool obscureText;
-        public readonly bool autocorrect;
-        //public readonly TextInputAction inputAction;
-        public readonly bool enableSuggestions;
-        public readonly TextCapitalization textCapitalization;
-        public readonly ui.Brightness keyboardAppearance;
-        public readonly bool unityTouchKeyboard;
-
-        public JSONNode toJson() {
-            var json = new JSONObject();
-            json["inputType"] = inputType.toJson();
-            json["obscureText"] = obscureText;
-            json["autocorrect"] = autocorrect;
-            //'smartDashesType': smartDashesType.index.toString(),
-            //'smartQuotesType': smartQuotesType.index.toString(),
-            json["enableSuggestions"] = enableSuggestions;
-            json["actionLabel"] = actionLabel;
-            json["inputAction"] = inputAction.ToString();
-            json["unityTouchKeyboard"] = unityTouchKeyboard;
-            json["textCapitalization"] = textCapitalization.ToString();
-            json["keyboardAppearance"] = keyboardAppearance.ToString();
-            return json;
-        }
+        //unity-specific
+        RawInputKeyResponse globalInputKeyHandler(RawKeyEvent evt);
     }
 
     public class TextInputConnection {
         
         internal Size _cachedSize;
         internal Matrix4 _cachedTransform;
+        
-            D.assert(to != null);
+        
+        
-            //TextInput._instance._show();
             
             Input.imeCompositionMode = IMECompositionMode.On;
             TextInput.keyboardDelegate.show();
             D.assert(attached);
             TextInput.keyboardDelegate.setEditingState(value);
-            //TextInput._instance._setEditingState(value);
+        
-                //var dictionary = new JSONObject();
-                //json["text"] = text;
+
                 Dictionary<string,object> dictionary = new Dictionary<string, object>();
                 dictionary["width"] = editableBoxSize.width;
                 dictionary["height"] = editableBoxSize.height;
                 );
             }
         }
+        
-             string fontFamily = null,
-             float? fontSize = null,
-             FontWeight fontWeight = null,
-             TextDirection? textDirection = null,
-             TextAlign? textAlign = null
-        ) { /// ????
+             string fontFamily,
+             float? fontSize,
+             FontWeight fontWeight,
+             TextDirection textDirection,
+             TextAlign textAlign
+        ) {
-            dictionary["textAlignIndex"] = textAlign?.GetHashCode();
-            dictionary["textDirectionIndex"] = textDirection?.GetHashCode();
+            dictionary["textAlignIndex"] = (int)textAlign;
+            dictionary["textDirectionIndex"] = (int)textDirection;
+        
-                //TextInput._instance._clearClient();
                 TextInput.keyboardDelegate.clearClient();
                 TextInput._currentConnection = null;
                 Input.imeCompositionMode = IMECompositionMode.Auto;
             TextInput._currentConnection = null;
             D.assert(!attached);
         }
+        
         internal readonly Window _window;
         TouchScreenKeyboard _keyboard;
     }
 
         public static TextInputConnection attach(TextInputClient client, TextInputConfiguration configuration) {
             D.assert(client != null);
+            D.assert(configuration != null);
             var connection = new TextInputConnection(client);
             _currentConnection = connection;
             if (keyboardDelegate != null) {

Samples/UIWidgetsSamples_2019_4/Assets/CountDemo.cs

+using System.Collections.Generic;
+using Unity.UIWidgets.cupertino;
+using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEngine.UI;
+using Text = Unity.UIWidgets.widgets.Text;
+using ui_ = Unity.UIWidgets.widgets.ui_;
+
+namespace UIWidgetsSample
+{
+    public class CountDemo : UIWidgetsPanel
+    {
+        protected void OnEnable()
+        {
+            base.OnEnable();
+        }
+
+        protected override void main()
+        {
+            ui_.runApp(new MyApp());
+        }
+
+        class MyApp : StatelessWidget
+        {
+            public override Widget build(BuildContext context)
+            {
+                return new CupertinoApp(
+                    home: new CounterApp()
+                );
+            }
+        }
+    }
+
+    internal class CounterApp : StatefulWidget
+    {
+        public override State createState()
+        {
+            return new CountDemoState();
+        }
+    }
+
+    internal class CountDemoState : State<CounterApp>
+    {
+        private int count = 0;
+
+        public override Widget build(BuildContext context)
+        {
+            return new Container(
+                color: Color.white,
+                child: new Column(children: new List<Widget>()
+                    {
+                        new Text($"count: {count}"),
+                        new CupertinoButton(
+                            onPressed: () =>
+                            {
+                                setState(() =>
+                                {
+                                    count++;
+                                });
+                            },
+                            child: new Container(
+                                color: Color.black,
+                                width: 100,
+                                height: 40
+                            )
+                        ),
+                    }
+                )
+            );
+        }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/CountDemo.unity

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &314921619
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 314921623}
+  - component: {fileID: 314921622}
+  - component: {fileID: 314921621}
+  - component: {fileID: 314921620}
+  m_Layer: 5
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &314921620
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 314921619}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &314921621
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 314921619}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 0
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &314921622
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 314921619}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &314921623
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 314921619}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 1777874941}
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!1 &624009034
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 624009037}
+  - component: {fileID: 624009036}
+  - component: {fileID: 624009035}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &624009035
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 624009034}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &624009036
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 624009034}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 10
+--- !u!4 &624009037
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 624009034}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1344837310
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1344837313}
+  - component: {fileID: 1344837312}
+  - component: {fileID: 1344837311}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1344837311
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1344837310}
+  m_Enabled: 1
+--- !u!20 &1344837312
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1344837310}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1344837313
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1344837310}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1763163838
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1763163840}
+  - component: {fileID: 1763163839}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &1763163839
+Light:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1763163838}
+  m_Enabled: 1
+  serializedVersion: 10
+  m_Type: 1
+  m_Shape: 0
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_InnerSpotAngle: 21.80208
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+    m_CullingMatrixOverride:
+      e00: 1
+      e01: 0
+      e02: 0
+      e03: 0
+      e10: 0
+      e11: 1
+      e12: 0
+      e13: 0
+      e20: 0
+      e21: 0
+      e22: 1
+      e23: 0
+      e30: 0
+      e31: 0
+      e32: 0
+      e33: 1
+    m_UseCullingMatrixOverride: 0
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingLayerMask: 1
+  m_Lightmapping: 4
+  m_LightShadowCasterMode: 0
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
+  m_UseBoundingSphereOverride: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1763163840
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1763163838}
+  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
+--- !u!1 &1777874940
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1777874941}
+  - component: {fileID: 1777874942}
+  - component: {fileID: 1777874943}
+  m_Layer: 5
+  m_Name: RawImage
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1777874941
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1777874940}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 314921623}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 100, y: 100}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &1777874942
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1777874940}
+  m_CullTransparentMesh: 0
+--- !u!114 &1777874943
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1777874940}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bb0c6b34bc87472499dccfb52a9bcbde, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Texture: {fileID: 0}
+  m_UVRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  fonts: []
+  devicePixelRatioOverride: 0
+  hardwareAntiAliasing: 0

Samples/UIWidgetsSamples_2019_4/Assets/CountDemo.unity.meta

+fileFormatVersion: 2
+guid: c157694a3a510e34aaf716cf9438dea5
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.uiwidgets/Runtime/material.meta

-fileFormatVersion: 2
-guid: ba4b5dab38db54970bf74725b5642400
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

com.unity.uiwidgets/Runtime/ui33.meta

-fileFormatVersion: 2
-guid: 628dbae83defc65479f1ad3d8c9acbfb
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: