Merge pull request #136 from Unity-Technologies/zgh/fix/EdgeInsets

rename and adjust function order

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

             return new Size(size.width - horizontal, size.height - vertical);
         }
 
-        public virtual EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
+        public virtual EdgeInsetsGeometry clamp(EdgeInsetsGeometry min, EdgeInsetsGeometry max) {
-                _left - other._left,
-                _right - other._right,
-                _start - other._start,
-                _end - other._end,
-                _top - other._top,
-                _bottom - other._bottom
+                _left.clamp(min._left, max._left),
+                _right.clamp(min._right, max._right),
+                _start.clamp(min._start, max._start),
+                _end.clamp(min._end, max._end),
+                _top.clamp(min._top, max._top),
+                _bottom.clamp(min._bottom, max._bottom)
             );
         }
 
             );
         }
 
-        public virtual EdgeInsetsGeometry clamp(EdgeInsetsGeometry min, EdgeInsetsGeometry max) {
+        public virtual EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
-                _left.clamp(min._left, max._left),
-                _right.clamp(min._right, max._right),
-                _start.clamp(min._start, max._start),
-                _end.clamp(min._end, max._end),
-                _top.clamp(min._top, max._top),
-                _bottom.clamp(min._bottom, max._bottom)
+                _left - other._left,
+                _right - other._right,
+                _start - other._start,
+                _end - other._end,
+                _top - other._top,
+                _bottom - other._bottom
-        public virtual EdgeInsetsGeometry mutilpy(float b) {
+        public virtual EdgeInsetsGeometry multiply(float b) {
             return _MixedEdgeInsets.fromLRSETB(
                 _left * b,
                 _right * b,
             );
         }
 
-        public static EdgeInsetsGeometry operator -(EdgeInsetsGeometry a, EdgeInsetsGeometry b) {
-            return a.subtract(b);
+        public static EdgeInsetsGeometry operator -(EdgeInsetsGeometry a) {
+            return a.multiply(-1.0f);
         }
 
         public static EdgeInsetsGeometry operator +(EdgeInsetsGeometry a, EdgeInsetsGeometry b) {
-        public static EdgeInsetsGeometry operator -(EdgeInsetsGeometry a) {
-            return a.mutilpy(-1.0f);
+        public static EdgeInsetsGeometry operator -(EdgeInsetsGeometry a, EdgeInsetsGeometry b) {
+            return a.subtract(b);
-            return a.mutilpy(other);
+            return a.multiply(other);
         }
 
         public static EdgeInsetsGeometry operator /(EdgeInsetsGeometry a, float other) {
         public static EdgeInsetsGeometry operator %(EdgeInsetsGeometry a, float other) {
             return a.remainder(other);
         }
-
 
         public static EdgeInsetsGeometry lerp(EdgeInsetsGeometry a, EdgeInsetsGeometry b, float t) {
             D.assert(t != null);
             get { return fromSTEB(end, bottom, start, top); }
         }
 
-        public override EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
-            return fromSTEB(
-                start - other._start,
-                end - other._end,
-                top - other._top,
-                bottom - other._bottom
-            );
-        }
-
         public override EdgeInsetsGeometry add(EdgeInsetsGeometry other) {
             return fromSTEB(
                 start + other._start,
             );
         }
 
-        public override EdgeInsetsGeometry mutilpy(float b){
+        public override EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
+            return fromSTEB(
+                start - other._start,
+                end - other._end,
+                top - other._top,
+                bottom - other._bottom
+            );
+        }
+
+        public override EdgeInsetsGeometry multiply(float b){
             return fromSTEB(
                 start * b,
                 end * b,
             );
         }
 
-        public static EdgeInsetsDirectional operator -(EdgeInsetsDirectional a, EdgeInsetsDirectional b) {
-            return a.subtract(b) as EdgeInsetsDirectional;
+        public static EdgeInsetsDirectional operator -(EdgeInsetsDirectional a) {
+            return a.multiply(-1.0f) as EdgeInsetsDirectional;
         }
 
         public static EdgeInsetsDirectional operator +(EdgeInsetsDirectional a, EdgeInsetsDirectional b) {
-        public static EdgeInsetsDirectional operator -(EdgeInsetsDirectional a) {
-            return a.mutilpy(-1.0f) as EdgeInsetsDirectional;
+        public static EdgeInsetsDirectional operator -(EdgeInsetsDirectional a, EdgeInsetsDirectional b) {
+            return a.subtract(b) as EdgeInsetsDirectional;
-            return a.mutilpy(b) as EdgeInsetsDirectional;
+            return a.multiply(b) as EdgeInsetsDirectional;
         }
 
         public static EdgeInsetsDirectional operator /(EdgeInsetsDirectional a, float b) {
             }
         }
 
-        public override EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
-            return fromLRSETB(
-                _left - other._left,
-                _right - other._right,
-                _start - other._start,
-                _end - other._end,
-                _top - other._top,
-                _bottom - other._bottom
-            );
-        }
-
         public override EdgeInsetsGeometry add(EdgeInsetsGeometry other) {
             return fromLRSETB(
                 _left + other._left,
             );
         }
 
-        public override EdgeInsetsGeometry mutilpy(float b){
+        public override EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
+            return fromLRSETB(
+                _left - other._left,
+                _right - other._right,
+                _start - other._start,
+                _end - other._end,
+                _top - other._top,
+                _bottom - other._bottom
+            );
+        }
+
+        public override EdgeInsetsGeometry multiply(float b){
             return fromLRSETB(
                 _left * b,
                 _right * b,
             );
         }
 
-        public static _MixedEdgeInsets operator -(_MixedEdgeInsets a, _MixedEdgeInsets b) {
-            return a.subtract(b) as _MixedEdgeInsets;
+        public static _MixedEdgeInsets operator -(_MixedEdgeInsets a) {
+            return a.multiply(-1.0f) as _MixedEdgeInsets;
         }
 
         public static _MixedEdgeInsets operator +(_MixedEdgeInsets a, _MixedEdgeInsets b) {
-        public static _MixedEdgeInsets operator -(_MixedEdgeInsets a) {
-            return a.mutilpy(-1.0f) as _MixedEdgeInsets;
+        public static _MixedEdgeInsets operator -(_MixedEdgeInsets a, _MixedEdgeInsets b) {
+            return a.subtract(b) as _MixedEdgeInsets;
-            return a.mutilpy(b) as _MixedEdgeInsets;
+            return a.multiply(b) as _MixedEdgeInsets;
         }
 
         public static _MixedEdgeInsets operator /(_MixedEdgeInsets a, float b) {
                 rect.right - right, rect.bottom - bottom);
         }
 
-        public override EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
+        public override EdgeInsetsGeometry clamp(EdgeInsetsGeometry min, EdgeInsetsGeometry max) {
-                left - other._left,
-                top - other._top,
-                right - other._right,
-                bottom - other._bottom
+                left.clamp(min._left, max._left),
+                top.clamp(min._top, max._top),
+                right.clamp(min._right, max._right),
+                bottom.clamp(min._bottom, max._bottom)
             );
         }
 
             );
         }
 
-        public override EdgeInsetsGeometry clamp(EdgeInsetsGeometry min, EdgeInsetsGeometry max) {
+        public override EdgeInsetsGeometry subtract(EdgeInsetsGeometry other) {
-                left.clamp(min._left, max._left),
-                top.clamp(min._top, max._top),
-                right.clamp(min._right, max._right),
-                bottom.clamp(min._bottom, max._bottom)
+                left - other._left,
+                top - other._top,
+                right - other._right,
+                bottom - other._bottom
-        public override EdgeInsetsGeometry mutilpy(float b){
+        public override EdgeInsetsGeometry multiply(float b){
             return fromLTRB(
                 left * b,
                 top * b,
             );
         }
 
-        public static EdgeInsets operator -(EdgeInsets a, EdgeInsets b) {
-            return a.subtract(b) as EdgeInsets;
+        public static EdgeInsets operator -(EdgeInsets a) {
+            return a.multiply(-1.0f) as EdgeInsets;
         }
 
         public static EdgeInsets operator +(EdgeInsets a, EdgeInsets b) {
-        public static EdgeInsets operator -(EdgeInsets a) {
-            return a.mutilpy(-1.0f) as EdgeInsets;
+        public static EdgeInsets operator -(EdgeInsets a, EdgeInsets b) {
+            return a.subtract(b) as EdgeInsets;
-            return a.mutilpy(b) as EdgeInsets;
+            return a.multiply(b) as EdgeInsets;
         }
 
         public static EdgeInsets operator /(EdgeInsets a, float b) {