update widgets

Assets/UIWidgets/rendering/error.cs

 
 namespace UIWidgets.rendering {
     public class RenderErrorBox : RenderBox {
-        const double _kMaxWidth = 100000.0;
-        const double _kMaxHeight = 100000.0;
         const string _kLine = "\n\n────────────────────\n\n";
 
         public RenderErrorBox(string message = "") {

Assets/UIWidgets/rendering/object.cs

             }
         }
 
-        void pushOpacity(Offset offset, int alpha, PaintingContextCallback painter) {
+        public void pushOpacity(Offset offset, int alpha, PaintingContextCallback painter) {
             this.pushLayer(new OpacityLayer(alpha), painter, offset);
         }
     }

Assets/UIWidgets/rendering/proxy_box.cs

             properties.add(new EnumerableProperty<string>("listeners", listeners));
         }
     }
+
+    public class RenderTransform : RenderProxyBox {
+        public RenderTransform(
+            Matrix4x4 transform,
+            Offset origin,
+            Alignment alignment,
+            TextDirection textDirection,
+            RenderBox child = null,
+            bool transformHitTests = true
+        ) {
+            this.transform = transform;
+            this.origin = origin;
+            this.alignment = alignment;
+            this.textDirection = textDirection;
+            this.child = child;
+            this.transformHitTests = transformHitTests;
+        }
+
+        public Offset origin {
+            get { return _origin; }
+            set {
+                if (_origin.Equals(value)) {
+                    return;
+                }
+
+                _origin = value;
+                markNeedsPaint();
+            }
+        }
+
+        private Offset _origin;
+
+        public Alignment alignment {
+            get { return _alignment; }
+            set {
+                if (_alignment.Equals(value)) {
+                    return;
+                }
+
+                _alignment = value;
+                markNeedsPaint();
+            }
+        }
+
+        private Alignment _alignment;
+
+        public TextDirection textDirection {
+            get { return _textDirection; }
+            set {
+                if (_textDirection.Equals(value)) {
+                    return;
+                }
+
+                _textDirection = value;
+                markNeedsPaint();
+            }
+        }
+
+        private TextDirection _textDirection;
+
+        public bool transformHitTests;
+
+        public Matrix4x4 transform {
+            set {
+                if (_transform.Equals(value)) {
+                    return;
+                }
+
+                _transform = value;
+            }
+        }
+
+        private Matrix4x4 _transform;
+    }
+
+    public class RenderOpacity : RenderProxyBox {
+        public RenderOpacity(RenderBox child = null, double opacity = 1.0) : base(child) {
+            D.assert(opacity >= 0.0 && opacity <= 1.0);
+            this._opacity = opacity;
+            this._alpha = _getAlphaFromOpacity(opacity);
+        }
+
+        public override bool alwaysNeedsCompositing {
+            get { return base.alwaysNeedsCompositing; }
+        }
+
+        private int _alpha;
+
+        private static int _getAlphaFromOpacity(double opacity) {
+            return (opacity * 255).round();
+        }
+
+        public double opacity {
+            get { return _opacity; }
+            set {
+                D.assert(value >= 0.0 && value <= 1.0);
+                if (_opacity == value) {
+                    return;
+                }
+
+                bool didNeedCompositing = alwaysNeedsCompositing;
+                bool wasVisible = _alpha != 0;
+                _opacity = value;
+                _alpha = _getAlphaFromOpacity(_opacity);
+                if (didNeedCompositing != alwaysNeedsCompositing) {
+                    markNeedsCompositingBitsUpdate();
+                }
+                markNeedsPaint();
+            }
+        }
+
+        private double _opacity;
+
+        public override void paint(PaintingContext context, Offset offset) {
+            if (child != null) {
+                if (_alpha == 0) {
+                    return;
+                }
+            }
+
+            if (_alpha == 255) {
+                context.paintChild(child, offset);
+                return;
+            }
+            D.assert(needsCompositing);
+            context.pushOpacity(offset, _alpha, base.paint);
+        }
+        
+    }
 }

Assets/UIWidgets/widgets/basic.cs

 using UIWidgets.painting;
 using UIWidgets.rendering;
 using UIWidgets.ui;
+using UnityEngine;
+using Color = UIWidgets.ui.Color;
+using Rect = UIWidgets.ui.Rect;
+    public class Directionality : InheritedWidget {
+        public Directionality(
+            Widget child,
+            TextDirection textDirection,
+            string key = null
+        ) : base(key, child) {
+            this.textDirection = textDirection;
+        }
+
+        public TextDirection textDirection;
+
+        public static TextDirection of(BuildContext context) {
+            Directionality widget = context.inheritFromWidgetOfExactType(typeof(Directionality)) as Directionality;
+            return widget == null ? TextDirection.ltr : widget.textDirection;
+        }
+
+        public override Element createElement() {
+            throw new NotImplementedException();
+        }
+
+        public override bool updateShouldNotify(InheritedWidget oldWidget) {
+            return textDirection != ((Directionality) oldWidget).textDirection;
+        }
+    }
+
+    public class Opacity : SingleChildRenderObjectWidget {
+        public Opacity(double opacity, string key = null, Widget child = null) : base(key, child) {
+            this.opacity = opacity;
+        }
+
+        public double opacity;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderOpacity(opacity: opacity);
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderOpacity) renderObject).opacity = opacity;
+        }
+    }
+
+    public class LimitedBox : SingleChildRenderObjectWidget {
+        public LimitedBox(
+            string key = null,
+            Widget child = null,
+            double maxWidth = double.MaxValue,
+            double maxHeight = double.MaxValue
+        ) : base(key, child) {
+            this.maxHeight = maxHeight;
+            this.maxWidth = maxWidth;
+        }
+
+        public double maxWidth;
+        public double maxHeight;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderLimitedBox(
+                maxWidth: maxWidth,
+                maxHeight: maxHeight
+            );
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderLimitedBox) renderObject).maxWidth = maxWidth;
+            ((RenderLimitedBox) renderObject).maxHeight = maxHeight;
+        }
+    }
+
+    public class ConstrainedBox : SingleChildRenderObjectWidget {
+        public ConstrainedBox(
+            string key = null,
+            BoxConstraints constraints = null,
+            Widget child = null
+        ) : base(key, child) {
+            this.constraints = constraints;
+        }
+
+        public BoxConstraints constraints;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderConstrainedBox(additionalConstraints: constraints);
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderConstrainedBox) renderObject)._additionalConstraints = constraints;
+        }
+    }
+
+    public class Padding : SingleChildRenderObjectWidget {
+        public Padding(
+            EdgeInsets padding,
+            string key = null,
+            Widget child = null
+        ) : base(key, child) {
+            this.padding = padding;
+        }
+
+        public EdgeInsets padding;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderPadding(
+                padding: padding
+            );
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderPadding) renderObject).padding = padding;
+        }
+    }
+
+    public class Transform : SingleChildRenderObjectWidget {
+        public Transform(
+            Matrix4x4 transform,
+            Offset origin = null,
+            Alignment alignment = null,
+            bool transformHitTests = false,
+            string key = null,
+            Widget child = null
+        ) : base(key, child) {
+            this.alignment = alignment ?? Alignment.center;
+            this.origin = origin;
+            this.transformHitTests = transformHitTests;
+            this.transform = transform;
+        }
+
+        // scale
+        public Transform(
+            double scale,
+            Offset origin,
+            Alignment alignment,
+            bool transformHitTests = false,
+            string key = null,
+            Widget child = null
+        ) : base(key, child) {
+            this.alignment = alignment ?? Alignment.center;
+            this.origin = origin;
+            this.transformHitTests = transformHitTests;
+            this.transform = Matrix4x4.Scale(new Vector3((float) scale, (float) scale, (float) 1.0));
+        }
+
+        public Matrix4x4 transform;
+        public Offset origin;
+        public Alignment alignment;
+        public bool transformHitTests;
+        
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderTransform(
+                transform: transform,
+                origin: origin,
+                alignment: alignment,
+                textDirection: Directionality.of(context),
+                transformHitTests: transformHitTests
+            );
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderTransform) renderObject).transform = transform;
+            ((RenderTransform) renderObject).origin = origin;
+            ((RenderTransform) renderObject).alignment = alignment;
+            ((RenderTransform) renderObject).textDirection = Directionality.of(context);
+            ((RenderTransform) renderObject).transformHitTests = transformHitTests;
+        }
+    }
+
+
+    public class Align : SingleChildRenderObjectWidget {
+        public Align(
+            double widthFactor = 0.0,
+            double heightFactor = 0.0,
+            string key = null,
+            Widget child = null,
+            Alignment alignment = null
+        ) : base(key, child) {
+            this.alignment = alignment ?? Alignment.center;
+            this.widthFactor = widthFactor;
+            this.heightFactor = heightFactor;
+        }
+
+        public Alignment alignment;
+
+        public double widthFactor;
+
+        public double heightFactor;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderPositionedBox(
+                alignment: alignment,
+                widthFactor: widthFactor,
+                heightFactor: heightFactor
+            );
+        }
+    }
+
     public class RawImage : LeafRenderObjectWidget {
         public RawImage(string key, ui.Image image, double width, double height, double scale, Color color,
             BlendMode colorBlendMode, BoxFit fit, Rect centerSlice, Alignment alignment = null,
         public ImageRepeat repeat;
         public Rect centerSlice;
     }
-
 }

Assets/UIWidgets/widgets/binding.cs

 
         public RenderObjectWithChildMixinRenderObject<T> container;
 
-        public String debugShortDescription;
+        public string debugShortDescription;
 
         public override Element createElement() {
             return new RenderObjectToWidgetElement<T>(this);
 
         public RenderObjectToWidgetElement<T> attachToRenderTree(BuildOwner owner, RenderObjectToWidgetElement<T> element) {
             if (element == null) {
-                // lock state?
                 element = (RenderObjectToWidgetElement<T>) createElement();
                 element.assignOwner(owner);
                 owner.buildScope(element, () => { element.mount(null, null); });

Assets/UIWidgets/widgets/framework.cs

     }
 
     public abstract class SingleChildRenderObjectWidget : RenderObjectWidget {
-        protected SingleChildRenderObjectWidget(string key) : base(key) {
+        protected SingleChildRenderObjectWidget(string key, Widget child) : base(key) {
+            this.child = child;
         }
 
         public Widget child;

Assets/UIWidgets/widgets/image.cs

 using Rect = UnityEngine.Rect;
 
 namespace UIWidgets.widgets {
-    internal class Util {
-        public static ImageConfiguration createLocalImageConfiguration(BuildContext context, Size size) {
+    internal class ImageUtil {
+        public static ImageConfiguration createLocalImageConfiguration(BuildContext context, Size size = null) {
             return new ImageConfiguration(
                 size: size
             );
         void _resolveImage() {
             var imageWidget = (Image<T>) widget;
             ImageStream newStream =
-                imageWidget.image.resolve(Util.createLocalImageConfiguration(
+                imageWidget.image.resolve(ImageUtil.createLocalImageConfiguration(
                     context,
                     size: new Size(imageWidget.width, imageWidget.height)
                 ));

Assets/UIWidgets/widgets/container.cs

+using System;
+using System.Collections.Generic;
+using UIWidgets.foundation;
+using UIWidgets.rendering;
+using UIWidgets.painting;
+using UnityEngine;
+using Color = UIWidgets.ui.Color;
+
+namespace UIWidgets.widgets {
+    public class DecoratedBox : SingleChildRenderObjectWidget {
+        public DecoratedBox(
+            Decoration decoration,
+            Widget child,
+            string key = null,
+            DecorationPosition position = DecorationPosition.background
+        ) : base(key, child) {
+            this.position = position;
+            this.decoration = decoration;
+        }
+
+        public Decoration decoration;
+
+        public DecorationPosition position;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderDecoratedBox(
+                decoration: decoration,
+                position: position,
+                configuration: ImageUtil.createLocalImageConfiguration(context)
+            );
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderDecoratedBox) renderObject).decoration = decoration;
+            ((RenderDecoratedBox) renderObject).configuration = ImageUtil.createLocalImageConfiguration(context);
+            ((RenderDecoratedBox) renderObject).position = position;
+        }
+    }
+
+    public class Container : StatelessWidget {
+        public Container(
+            string key,
+            Alignment alignment,
+            EdgeInsets padding,
+            Color color,
+            Decoration decoration,
+            Decoration forgroundDecoration,
+            double width,
+            double height,
+            BoxConstraints constraints,
+            EdgeInsets margin,
+            Matrix4x4 transfrom,
+            Widget child
+        ) : base(key) {
+            this.alignment = alignment;
+            this.foregroundDecoration = forgroundDecoration;
+            this.transform = transfrom;
+            this.margin = margin;
+            this.child = child;
+            this.padding = padding;
+
+            this.decoration = decoration ?? (color != null ? new BoxDecoration(color) : null);
+            this.constraints = (width != 0.0 || height != 0.0)
+                ? ((constraints == null ? null : constraints.tighten(width, height))
+                   ?? BoxConstraints.tightFor(width, height))
+                : constraints;
+        }
+
+        public Widget child;
+        public Alignment alignment;
+        public EdgeInsets padding;
+        public Decoration decoration;
+        public Decoration foregroundDecoration;
+        public BoxConstraints constraints;
+        public EdgeInsets margin;
+        public Matrix4x4 transform;
+
+        EdgeInsets _paddingIncludingDecoration {
+            get {
+                if (decoration == null || decoration.padding == null)
+                    return padding;
+                EdgeInsets decorationPadding = decoration.padding;
+                if (padding == null)
+                    return decorationPadding;
+                return padding.add(decorationPadding);
+            }
+        }
+
+        public override Widget build(BuildContext context) {
+            Widget current = child;
+
+            if (child == null && (constraints == null || !constraints.isTight)) {
+                current = new LimitedBox(
+                    maxWidth: 0.0,
+                    maxHeight: 0.0,
+                    child: new ConstrainedBox(constraints: BoxConstraints.expand())
+                );
+            }
+
+            if (alignment != null) {
+                current = new Align(alignment: alignment, child: current);
+            }
+
+            EdgeInsets effetivePadding = _paddingIncludingDecoration;
+            if (effetivePadding != null) {
+                current = new Padding(padding: effetivePadding, child: current);
+            }
+
+            if (decoration != null) {
+                current = new DecoratedBox(decoration: decoration, child: current);
+            }
+
+            if (foregroundDecoration != null) {
+                current = new DecoratedBox(
+                    decoration: decoration,
+                    position: DecorationPosition.foreground,
+                    child: current
+                );
+            }
+
+            if (constraints != null) {
+                current = new ConstrainedBox(constraints: constraints, child: current);
+            }
+
+            if (margin != null) {
+                current = new Padding(padding: margin, child: current);
+            }
+
+            if (transform != null) {
+                current = new Transform(transform: transform, child: current);
+            }
+
+            return current;
+        }
+    }
+}

Assets/UIWidgets/widgets/container.cs.meta

+fileFormatVersion: 2
+guid: 7c96e4ace3a14122bc2107afe55771da
+timeCreated: 1536831109