run widget

Samples/UIWidgetsSamples_2019_4/Assets/TextTest.unity

   - component: {fileID: 847097469}
   - component: {fileID: 847097471}
   - component: {fileID: 847097470}
+  - component: {fileID: 847097472}
   m_Layer: 5
   m_Name: RawImage
   m_TagString: Untagged
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 847097468}
-  m_Enabled: 1
+  m_Enabled: 0
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: db61290d6ca38264995f5749021d562c, type: 3}
   m_Name: 
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 847097468}
   m_CullTransparentMesh: 0
+--- !u!114 &847097472
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 847097468}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 169ec79ce040653478e1a7725f34bbe1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  fonts: []
 --- !u!1 &1140493537
 GameObject:
   m_ObjectHideFlags: 0

com.unity.uiwidgets/Editor/UIWidgetsPanelEditor.cs

 using UnityEditor.UI;
 
 namespace Unity.UIWidgets.Editor {
-    [CustomEditor(typeof(UIWidgetsPanel), true)]
-    [CanEditMultipleObjects]
-    public class UIWidgetsPanelEditor : RawImageEditor {
-        public override void OnInspectorGUI() {
-            base.OnInspectorGUI();
-            var pixelRatioProperty = serializedObject.FindProperty("devicePixelRatioOverride");
-            var antiAliasingProperty = serializedObject.FindProperty("hardwareAntiAliasing");
-            EditorGUILayout.PropertyField(pixelRatioProperty);
-            EditorGUILayout.PropertyField(antiAliasingProperty);
-            serializedObject.ApplyModifiedProperties(); 
-        }
-    }
+    // [CustomEditor(typeof(UIWidgetsPanel.UIWidgetRawImage), true)]
+    // [CanEditMultipleObjects]
+    // public class UIWidgetsPanelEditor : RawImageEditor {
+    //     public override void OnInspectorGUI() {
+    //         base.OnInspectorGUI();
+    //         var pixelRatioProperty = serializedObject.FindProperty("devicePixelRatioOverride");
+    //         var antiAliasingProperty = serializedObject.FindProperty("hardwareAntiAliasing");
+    //         EditorGUILayout.PropertyField(pixelRatioProperty);
+    //         EditorGUILayout.PropertyField(antiAliasingProperty);
+    //         serializedObject.ApplyModifiedProperties(); 
+    //     }
+    // }
 }

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

 using NativeBindings = Unity.UIWidgets.ui.NativeBindings;
 
 namespace Unity.UIWidgets.engine2 {
-    public partial class UIWidgetsPanel : MonoBehaviour {
+    public partial class UIWidgetsPanel : MonoBehaviour{
         [Serializable]
         public class TextFont {
             public string path;
         public List<TextFont> fonts;
 
         public class UIWidgetRawImage : RawImage {
+            public void SetPanel(UIWidgetsPanel panel) {
+                _uiWidgetsPanel = panel;
+            }
+            
             UIWidgetsPanel _uiWidgetsPanel;
 
             protected override void OnRectTransformDimensionsChange() {
         
-        UIWidgetRawImage _rawImage;
+        RawImage _rawImage;
         RectTransform rectTransform {
             get { return _rawImage.rectTransform; }
         }
             }
         }
 
-        void OnEnable() {
-            _rawImage = gameObject.AddComponent<UIWidgetRawImage>();
+        protected void OnEnable() {
+            _rawImage = gameObject.GetComponent<RawImage>();
+            if (_rawImage == null) {
+                _rawImage = gameObject.AddComponent<UIWidgetRawImage>();
+                ((UIWidgetRawImage)_rawImage).SetPanel(this);
+            }
+
             _recreateRenderTexture(_currentWidth, _currentHeight, _currentDevicePixelRatio);
 
             _handle = GCHandle.Alloc(this);

com.unity.uiwidgets/Runtime/ui2/window.cs

             }
         }
 
-        string _initialLifecycleState;
+        string _initialLifecycleState = "AppLifecycleState.resumed";
         bool _initialLifecycleStateAccessed = false;
         public float textScaleFactor { get; internal set; } = 1.0f;
 

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

 using System.Collections.Generic;
 using Unity.UIWidgets.async2;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;
 using UnityEngine;
 
         Future<bool> didPushRoute(string route);
     }
-    
+
     public static partial class ui_ {
         public static void Each<T>(this IEnumerable<T> source, Action<T> fn) {
             foreach (var item in source) {
             foreach (var item in items) {
                 yield return item;
             }
+        }
+
+        public static void runApp(Widget app) {
+            var instance = WidgetsFlutterBinding.ensureInitialized();
+            instance.scheduleAttachRootWidget(app);
+            instance.scheduleWarmUpFrame();
         }
     }
 
 
         public void handlePopRoute() {
             var idx = -1;
-            
+
             void _handlePopRouteSub(bool result) {
                 if (!result) {
                     idx++;
                     }
+
-            
+
             _handlePopRouteSub(false);
         }
 
                 observer.didChangeTextScaleFactor();
             }
         }
-        
+
         protected override void handlePlatformBrightnessChanged() {
             base.handlePlatformBrightnessChanged();
             foreach (WidgetsBindingObserver observer in _observers) {
             if (_renderViewElement == null) {
                 return;
             }
-            
+
-            
+
+        }
+
+        internal void scheduleAttachRootWidget(Widget rootWidget) {
+            Timer.run(() => {
+                attachRootWidget(rootWidget);
+                return null;
+            });
         }
 
         public void attachRootWidget(Widget rootWidget) {
         protected override void removeChildRenderObject(RenderObject child) {
             D.assert(renderObject.child == child);
             renderObject.child = null;
+        }
+    }
+
+    public class WidgetsFlutterBinding : WidgetsBinding {
+        public static WidgetsBinding ensureInitialized() {
+            if (WidgetsBinding.instance == null)
+                new WidgetsFlutterBinding();
+            return WidgetsBinding.instance;
         }
     }
 }

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsExample.cs

+ using System.Collections.Generic;
+ using Unity.UIWidgets.animation;
+ using Unity.UIWidgets.engine;
+ using Unity.UIWidgets.engine2;
+ using Unity.UIWidgets.foundation;
+ using Unity.UIWidgets.material;
+ using Unity.UIWidgets.painting;
+ using Unity.UIWidgets.ui;
+ using Unity.UIWidgets.widgets;
+ using UnityEngine;
+ using FontStyle = Unity.UIWidgets.ui.FontStyle;
+ using ui_ = Unity.UIWidgets.widgets.ui_;
+
+ namespace UIWidgetsSample {
+     public class UIWidgetsExample : UIWidgetsPanel {
+        
+         
+         protected void OnEnable() {
+             // if you want to use your own font or font icons.
+             // FontManager.instance.addFont(Resources.Load<Font>(path: "path to your font"), "font family name");
+
+             // load custom font with weight & style. The font weight & style corresponds to fontWeight, fontStyle of
+             // a TextStyle object
+             // FontManager.instance.addFont(Resources.Load<Font>(path: "path to your font"), "Roboto", FontWeight.w500,
+             //    FontStyle.italic);
+
+             // add material icons, familyName must be "Material Icons"
+             // FontManager.instance.addFont(Resources.Load<Font>(path: "path to material icons"), "Material Icons");
+
+             base.OnEnable();
+         }
+
+         protected override void main()
+         {
+             ui_.runApp(new MyApp());
+         }
+
+         class MyApp : StatelessWidget
+         {
+             public override Widget build(BuildContext context)
+             {
+                 return new WidgetsApp(
+                     home: new ExampleApp(),
+                     pageRouteBuilder: (RouteSettings settings, WidgetBuilder builder) =>
+                         new PageRouteBuilder(
+                             settings: settings,
+                             pageBuilder: (BuildContext Buildcontext, Animation<float> animation,
+                                 Animation<float> secondaryAnimation) => builder(context)
+                         )
+                 );
+             }
+         }
+         // protected override Widget createWidget() {
+         //     return new WidgetsApp(
+         //         home: new ExampleApp(),
+         //         pageRouteBuilder: (RouteSettings settings, WidgetBuilder builder) =>
+         //             new PageRouteBuilder(
+         //                 settings: settings,
+         //                 pageBuilder: (BuildContext context, Animation<float> animation,
+         //                     Animation<float> secondaryAnimation) => builder(context)
+         //             )
+         //     );
+         // }
+
+         class ExampleApp : StatefulWidget {
+             public ExampleApp(Key key = null) : base(key) {
+             }
+
+             public override State createState() {
+                 return new ExampleState();
+             }
+         }
+
+         class ExampleState : State<ExampleApp> {
+             int counter = 0;
+
+             public override Widget build(BuildContext context) {
+                 return new Column(
+                     children: new List<Widget> {
+                         new Text("Counter: " + this.counter),
+                         new GestureDetector(
+                             onTap: () => {
+                                 this.setState(()
+                                     => {
+                                     this.counter++;
+                                 });
+                             },
+                             child: new Container(
+                                 padding: EdgeInsets.symmetric(20, 20),
+                                 color: Colors.blue,
+                                 child: new Text("Click Me")
+                             )
+                         )
+                     }
+                 );
+             }
+         }
+     }
+ }