Merge pull request #76 from Unity-Technologies/siyaoH/1.17/keyboard

Siyao h/1.17/keyboard

Samples/UIWidgetsSamples_2019_4/Assets/Script/TextTest.cs

             public override Widget build(BuildContext context)
             {
                 return new CupertinoApp(
-                    home: new HomeScreen()//new DetailScreen1("ok")
+                    home: new HomeScreen() //new DetailScreen1("ok")
                     //color: Color.white
                 );
             }

Samples/UIWidgetsSamples_2019_4/Assets/UIWidgetsGallery/demo/cupertino/cupertino_switch_demo.cs

                                                 "Disabled - Off"
                                             ),
                                         }
-                                    )
+                                    ),
                                 }
                             )
                         )

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/NavigationSample.cs

         {
             ui_.runApp(new MyApp());
         }
-        
-        
-        
-            
+
         class MyApp : StatelessWidget
         {
             public override Widget build(BuildContext context)
             }
         }
     }
-    
-    public class CustomButton : StatelessWidget {
-        public CustomButton(
-            Key key = null,
-            GestureTapCallback onPressed = null,
-            EdgeInsets padding = null,
-            Color backgroundColor = null,
-            Widget child = null
-        ) : base(key: key) {
-            this.onPressed = onPressed;
-            this.padding = padding ?? EdgeInsets.all(8.0f);
-            this.backgroundColor = backgroundColor ?? Colors.white;
-            this.child = child;
-        }
-
-        public readonly GestureTapCallback onPressed;
-        public readonly EdgeInsets padding;
-        public readonly Widget child;
-        public readonly Color backgroundColor;
-
-        public override Widget build(BuildContext context) {
-            return new GestureDetector(
-                onTap: this.onPressed,
-                child: new Container(
-                    padding: this.padding,
-                    color: this.backgroundColor,
-                    child: this.child
-                )
-            );
-        }
-    }
-
 
     class HomeScreen : StatelessWidget {
         public override Widget build(BuildContext context) {

com.unity.uiwidgets/Runtime/cupertino/text_field.cs

 using Unity.UIWidgets.service;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
+using UnityEngine;
+using Color = Unity.UIWidgets.ui.Color;
 
 namespace Unity.UIWidgets.cupertino {
     class CupertinoTextFieldUtils {
 
         public GlobalKey<EditableTextState> editableTextKey {
             get {
-                return GlobalKey<EditableTextState>.key();
+                return _editableTextKey;
+        public readonly GlobalKey<EditableTextState>  _editableTextKey =  GlobalKey<EditableTextState>.key();
+
-        //public readonly GlobalKey<EditableTextState>  editableTextKey =  GlobalKey<EditableTextState>.key();
 
         public bool selectionEnabled {
             get { return widget.selectionEnabled;}

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

 using System.Runtime.InteropServices;
 using AOT;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.services;
 using Unity.UIWidgets.ui;
 using UnityEngine;
 #if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
     public partial class UIWidgetsPanel {
         RenderTexture _renderTexture;
-    
+
         void _createRenderTexture(int width, int height, float devicePixelRatio) {
             D.assert(_renderTexture == null);
 
 
             texture = _renderTexture;
         }
-    
+
         void _destroyRenderTexture() {
             D.assert(_renderTexture != null);
             texture = null;
-    
-        void _enableUIWidgetsPanel(string font_settings)
-        {
+
+        void _enableUIWidgetsPanel(string font_settings) {
-    
-        void _resizeUIWidgetsPanel()
-        {
+
+        void _resizeUIWidgetsPanel() {
-                        _renderTexture.GetNativeTexturePtr(),
-                        _width, _height, _devicePixelRatio);
+                _renderTexture.GetNativeTexturePtr(),
+                _width, _height, _devicePixelRatio);
-    
+
-    
-        
+
+
-            IntPtr nativeTexturePtr, int width, int height, float dpi, string streamingAssetsPath, string font_settings);
-        
+            IntPtr nativeTexturePtr, int width, int height, float dpi, string streamingAssetsPath,
+            string font_settings);
+
         [DllImport(NativeBindings.dllName)]
         static extern void UIWidgetsPanel_onRenderTexture(
             IntPtr ptr, IntPtr nativeTexturePtr, int width, int height, float dpi);
             IntPtr ptr, int width, int height, float dpi);
     }
 #endif
-    
+
     public partial class UIWidgetsPanel : RawImage {
         [Serializable]
         public struct Font {
-        
+
         [Serializable]
         public struct TextFont {
             public string family;
             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>();
                     if (textFont[i].fonts[j].asset.Length > 0) {
                         dic[j].Add("asset", textFont[i].fonts[j].asset);
                     }
+
+
+
-        public float devicePixelRatioOverride;
+        public float devicePixelRatioOverride = 1;
+
 
         public float hardwareAntiAliasing;
         // RectTransform rectTransform {
 
         IntPtr _ptr;
         GCHandle _handle;
-        
+
         int _width;
         int _height;
         float _devicePixelRatio;
             if (fonts != null && fonts.Length > 0) {
                 settings.Add("fonts", fontsToObject(fonts));
             }
-            
+
             _enableUIWidgetsPanel(JSONMessageCodec.instance.toJson(settings));
 
             Input_OnEnable();
             _handle = default;
 
             _disableUIWidgetsPanel();
-            
+
             D.assert(!isolate.isValid);
             base.OnDisable();
         }
             Event e = Event.current;
             if (e.isKey) {
                 UIWidgetsPanel_onKey(_ptr, e.keyCode, e.type == EventType.KeyDown);
-                if (e.character != 0) {
-                    UIWidgetsPanel_onChar(_ptr, e.character);
+                if (e.character != 0 || e.keyCode == KeyCode.Backspace) {
+                    PointerEventConverter.KeyEvent.Enqueue(new Event(e));
+                    // TODO: add on char
+                    // UIWidgetsPanel_onChar(_ptr, e.character);
                 }
             }
         }
             _isEntered = false;
             UIWidgetsPanel_onMouseLeave(_ptr);
         }
-        
+
         public void OnDrag(PointerEventData eventData) {
             var pos = _getPointerPosition(Input.mousePosition);
             if (pos == null) {

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

+using System;
+using Unity.UIWidgets.service;
 using UnityEngine;
 
 namespace Unity.UIWidgets.gestures {
                 var radiusMax = _toLogicalPixels(datum.radiusMax, devicePixelRatio);
                 var timeStamp = datum.timeStamp;
                 var kind = datum.kind;
+                // TODO: datum.signalKind is not nullable, "else" could not be reached
                 if (datum.signalKind == null || datum.signalKind == ui.PointerSignalKind.none) {
                     switch (datum.change) {
                         case PointerChange.add: {
                                 radiusMax: radiusMax
                             );
                             break;
+                        default:
+                        //TODO: PUT KEYBOARD TO A PROPRER POSITION
+                            if (datum.kind == PointerDeviceKind.keyboard) {
+                                var keyBoardEvent = new Event();
+                                if (datum.change == PointerChange.kMouseDown) {
+                                    keyBoardEvent.type = EventType.KeyDown;
+                                }else if (datum.change == PointerChange.kMouseUp) {
+                                    keyBoardEvent.type = EventType.KeyUp;
+                                }
+
+                                keyBoardEvent.keyCode = (KeyCode)datum.buttons;
+
+                                RawKeyboard.instance._handleKeyEvent(keyBoardEvent);
+                                TextInput.OnGUI();
+                            }
+                            break;
                     }
                 }
                 else {
             }
         }
 
+        public static Queue<Event> KeyEvent = new Queue<Event>();
         static float _toLogicalPixels(float physicalPixels, float devicePixelRatio) {
             return physicalPixels / devicePixelRatio;
         }

com.unity.uiwidgets/Runtime/material/input_decorator.cs

                 return _textAlignVertical;
             }
             set {
-                D.assert(value != null);
                 if (_textAlignVertical == value) {
                     return;
                 }
         ) : base(key: key) {
             D.assert(decoration != null);
             D.assert(textDirection != null);
-            D.assert(textAlignVertical != null);
             D.assert(textBaseline != null);
             D.assert(expands != null);
             this.decoration = decoration;

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

-
+using Unity.UIWidgets.async2;
+using Unity.UIWidgets.gestures;
-
+
-    
-    public delegate RawInputKeyResponse GlobalKeyEventHandlerDelegate(RawKeyEvent rawEvt, bool enableCustomAction = false);
-    
+    public delegate RawInputKeyResponse GlobalKeyEventHandlerDelegate(RawKeyEvent rawEvt,
+        bool enableCustomAction = false);
+
     public class RawInputKeyResponse {
         public readonly bool swallow;
         public readonly char input;
             this.input = input;
             this.inputAction = inputAction;
         }
-        
+
-                false, 
+                false,
                 evt.data.unityEvent.character,
                 null);
         }
 
-    interface KeyboardDelegate: IDisposable {
+    interface KeyboardDelegate : IDisposable {
-        
+
         void setStyle(Dictionary<string, object> args);
         void setIMEPos(Offset imeGlobalPos);
 
         bool imeRequired();
-        
-        
-    
+
-
-        
+
         TextEditingValue _value;
 
         public void show() {
         }
 
         public void setEditableSizeAndTransform(Dictionary<string, object> args) {
-             //todo
+            //todo
-             //todo 
+            //todo 
         }
 
         Offset _editorWindowPosToScreenPos(Offset position) {
 
         public void setIMEPos(Offset imeGlobalPos) {
             var uiWidgetWindowAdapter = Window.instance;
-            Offset screenPos = uiWidgetWindowAdapter != null 
-                ? uiWidgetWindowAdapter.windowPosToScreenPos(imeGlobalPos) 
+            Offset screenPos = uiWidgetWindowAdapter != null
+                ? uiWidgetWindowAdapter.windowPosToScreenPos(imeGlobalPos)
-            
+
             Input.compositionCursorPos = new Vector2(screenPos.dx, screenPos.dy);
         }
 
             if (_client == 0) {
                 return;
             }
-            
-            
-            var currentEvent = Event.current;
-            var oldValue = _value;
-            if (currentEvent != null && currentEvent.type == EventType.KeyDown) {
-                var response = TextInput._handleGlobalInputKey(_client,
-                    new RawKeyDownEvent(new RawKeyEventData(currentEvent)));
-                if (response.swallow) {
-                    if (response.inputAction != null) {
-                        Window.instance.run(() => { TextInput._performAction(_client, response.inputAction.Value); });
+            while (!PointerEventConverter.KeyEvent.isEmpty()) {
+                var currentEvent = PointerEventConverter.KeyEvent.Dequeue();
+                var oldValue = _value;
+
+                if (currentEvent != null && currentEvent.type == EventType.KeyDown) {
+                    var response = TextInput._handleGlobalInputKey(_client,
+                        new RawKeyDownEvent(new RawKeyEventData(currentEvent)));
+
+                    if (response.swallow) {
+                        if (response.inputAction != null) {
+                            Timer.create(TimeSpan.Zero,
+                                () => { TextInput._performAction(_client, response.inputAction.Value); });
+                        }
+
+                        if (_validateCharacter(response.input)) {
+                            _value = _value.insert(new string(response.input, 1));
+                        }
-                    
-                    if (_validateCharacter(response.input)) {
-                        _value = _value.insert(new string(response.input, 1));
+                    else if (currentEvent.keyCode == KeyCode.Backspace) {
+                        if (_value.selection.isValid) {
+                            _value = _value.deleteSelection(true);
+                        }
-                } else if (currentEvent.keyCode == KeyCode.Backspace) {
-                    if (_value.selection.isValid) {
-                        _value = _value.deleteSelection(true);
-                    }
-                } else if (currentEvent.character != '\0') {
-                    _value = _value.clearCompose();
-                    char ch = currentEvent.character;
-                    if (ch == '\r' || ch == 3) {
-                        ch = '\n';
-                    }
+                    else if (currentEvent.character != '\0') {
+                        _value = _value.clearCompose();
+                        char ch = currentEvent.character;
+                        if (ch == '\r' || ch == 3) {
+                            ch = '\n';
+                        }
-                    if (ch == '\n') {
-                        Window.instance.run(() => { TextInput._performAction(_client, TextInputAction.newline); });
+                        if (ch == '\n') {
+                            Timer.create(TimeSpan.Zero, () => { TextInput._performAction(_client, TextInputAction.newline); });
+                        }
+
+                        if (_validateCharacter(ch)) {
+                            _value = _value.insert(new string(ch, 1));
+                        }
-                    
-                    if (_validateCharacter(ch)) {
-                        _value = _value.insert(new string(ch, 1));
+                    else if (!string.IsNullOrEmpty(currentEvent.keyCode.ToString())) {
+                        isIMEInput = true;
+                        _value = _value.compose(currentEvent.keyCode.ToString());
+
+                    currentEvent.Use();
-                else if (!string.IsNullOrEmpty(Input.compositionString)) {
-                    isIMEInput = true;
-                    _value = _value.compose(Input.compositionString);
-                }
-                
-                currentEvent.Use();
-            }
-            if (_value != oldValue) {
-                if (this.isIMEInput) {
-                    var isIMEInput = this.isIMEInput;
-                    Window.instance.run(() => { TextInput._updateEditingState(_client, _value, isIMEInput); });
-                    this.isIMEInput = false;
-                }
-                else {
-                    Window.instance.run(() => { TextInput._updateEditingState(_client, _value); });
+                if (_value != oldValue) {
+                    if (this.isIMEInput) {
+                        var isIMEInput = this.isIMEInput;
+                        Timer.create(TimeSpan.Zero,
+                            () => { TextInput._updateEditingState(_client, _value, isIMEInput); });
+                        this.isIMEInput = false;
+                    }
+                    else {
+                        Timer.create(TimeSpan.Zero, () => { TextInput._updateEditingState(_client, _value, isIMEInput); });
+                    }
                 }
             }
         }
             return ch >= ' ' || ch == '\t' || ch == '\r' || ch == 10 || ch == '\n';
         }
     }
-    
+
     class UnityTouchScreenKeyboardDelegate : KeyboardDelegate, TextInputUpdateListener {
         int _client;
         string _lastCompositionString;
             if (_keyboard.status == TouchScreenKeyboard.Status.Done) {
                 if (!_screenKeyboardDone) {
                     _screenKeyboardDone = true;
-                    Window.instance.run(() => {
+                    Timer.create(TimeSpan.Zero, () => {
                         TextInput._performAction(_client,
                             TextInputAction.done);
                     });
                         : TextSelection.collapsed(0)
                 );
                 var changed = _value != newValue;
-                
+
-                    Window.instance.run(() => {
+                    Timer.create(TimeSpan.Zero, () => {
                         TextInput._updateEditingState(_client,
                             _value);
                     });
     }
 
     abstract class AbstractUIWidgetsKeyboardDelegate : KeyboardDelegate {
-        
-            UIWidgetsMessageManager.instance.
-                AddChannelMessageDelegate("TextInput", _handleMethodCall);
+            UIWidgetsMessageManager.instance.AddChannelMessageDelegate("TextInput", _handleMethodCall);
-        
+
-            UIWidgetsMessageManager.instance.
-                RemoveChannelMessageDelegate("TextInput", _handleMethodCall);
+            UIWidgetsMessageManager.instance.RemoveChannelMessageDelegate("TextInput", _handleMethodCall);
         }
 
         public abstract void show();
         public abstract void setEditingState(TextEditingValue value);
+
         public void setEditableSizeAndTransform(Dictionary<string, object> args) {
             throw new NotImplementedException();
         }
         public abstract void setClient(int client, TextInputConfiguration configuration);
 
         public abstract void clearClient();
+
         public virtual bool imeRequired() {
             return false;
         }
-            
+
             /*if (TextInput._currentConnection == null) {
                 return;
             }
                         throw new UIWidgetsError($"unknown method ${method}");
                 }
             }*/
-        } 
+        }
-    
+
 #if UNITY_WEBGL
     class UIWidgetsWebGLKeyboardDelegate : AbstractUIWidgetsKeyboardDelegate {
         
 
     }
 #endif
-    
+
 #if UNITY_IOS || UNITY_ANDROID
     class UIWidgetsTouchScreenKeyboardDelegate : AbstractUIWidgetsKeyboardDelegate {
 
 #elif UNITY_ANDROID
         internal static void UIWidgetsTextInputShow() {
             using (
-                AndroidJavaClass pluginClass = new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
+                AndroidJavaClass pluginClass =
+ new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
             ) {
                 pluginClass.CallStatic("show");
             }
             using (
-                AndroidJavaClass pluginClass = new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
+                AndroidJavaClass pluginClass =
+ new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
             ) {
                 pluginClass.CallStatic("hide");
             }
             using (
-                AndroidJavaClass pluginClass = new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
+                AndroidJavaClass pluginClass =
+ new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
             ) {
                
                 pluginClass.CallStatic("setClient", client, configuration);
         internal static void UIWidgetsTextInputSetTextInputEditingState(string jsonText) {
             using (
-                AndroidJavaClass pluginClass = new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
+                AndroidJavaClass pluginClass =
+ new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
             ) {
                 pluginClass.CallStatic("setEditingState", jsonText);
             }
             using (
-                AndroidJavaClass pluginClass = new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
+                AndroidJavaClass pluginClass =
+ new AndroidJavaClass("com.unity.uiwidgets.plugin.editing.TextInputPlugin")
             ) {
                 pluginClass.CallStatic("clearClient");
             }
-#endif  
+#endif
 }

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

             TextSelection selection = null,
             TextRange composing = null) {
             selection = selection ?? TextSelection.collapsed(offset: -1);
+            
             D.assert(text != null);
             this.text = text;
             this.composing = composing ?? TextRange.empty;
         
         static int _nextId = 1;
         internal readonly int _id;
+        
+        public void setIMEPos(Offset imeGlobalPos) {
+            D.assert(attached);
+            D.assert(imeGlobalPos != null);
+            D.assert(imeRequired());
+            TextInput.keyboardDelegate.setIMEPos(imeGlobalPos);
+        }
+        
+        public bool imeRequired() {
+            return TextInput.keyboardDelegate != null && TextInput.keyboardDelegate.imeRequired();
+        }
+        
         public static void debugResetId(int to = 1) {
             D.assert(() =>{
                 _nextId = to;

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

         down,
         move,
         up,
+        kMouseDown,
+        kMouseUp,
-        touch,
-        mouse,
+        touch = 0,
+        mouse = 1,
-        unknown
+        keyboard = 4,
+        unknown,
     }
 
     public enum PointerSignalKind {

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

 
         public string textInside(string text) {
             D.assert(isNormalized);
-            return text.Substring(start, end);
+            return text.Substring(start, end - start);
         }
 
         public override string ToString() {

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

             bool cursorOpacityAnimates = false,
             Offset cursorOffset = null,
             bool paintCursorAboveText = false,
-            ui.BoxHeightStyle selectionHeightStyle = ui.BoxHeightStyle.tight,
-            ui.BoxWidthStyle selectionWidthStyle = ui.BoxWidthStyle.tight,
+            BoxHeightStyle selectionHeightStyle = BoxHeightStyle.tight,
+            BoxWidthStyle selectionWidthStyle = BoxWidthStyle.tight,
             EdgeInsets scrollPadding = null,
             Brightness? keyboardAppearance = Brightness.light,
             DragStartBehavior dragStartBehavior = DragStartBehavior.start,
         public readonly VoidCallback onSelectionHandleTapped;
         public readonly ScrollController scrollController;
         public readonly bool showCursor;
-        public readonly ui.BoxHeightStyle selectionHeightStyle;
-        public readonly ui.BoxWidthStyle selectionWidthStyle;
+        public readonly BoxHeightStyle selectionHeightStyle;
+        public readonly BoxWidthStyle selectionWidthStyle;
         public readonly bool forceLine;
         public readonly bool showSelectionHandles ;
         public readonly ToolbarOptions toolbarOptions;
             properties.add( new DiagnosticsProperty<bool>("enableSuggestions", enableSuggestions, defaultValue: true));
             style?.debugFillProperties(properties);
             properties.add( new EnumProperty<TextAlign>("textAlign", textAlign, defaultValue: null));
-            properties.add( new EnumProperty<TextDirection>("textDirection", textDirection.Value, defaultValue: null));
+            properties.add( new EnumProperty<TextDirection?>("textDirection", textDirection, defaultValue: null));
             properties.add( new DiagnosticsProperty<Locale>("locale", locale, defaultValue: null));
             properties.add( new FloatProperty("textScaleFactor", textScaleFactor, defaultValue: null));
             properties.add( new IntProperty("maxLines", maxLines, defaultValue: 1));
 
         void _didChangeTextEditingValue() {
             _updateRemoteEditingValueIfNeeded();
-            //_updateImePosIfNeed();
+            _updateImePosIfNeed();
             _startOrStopCursorTimerIfNeeded();
             _updateOrDisposeSelectionOverlayIfNeeded();
             _textChangedSinceLastCaretUpdate = true;
             return TouchScreenKeyboard.isSupported && widget.unityTouchKeyboard;
         }
 
-        
+        Offset _getImePos() {
+            if (_hasInputConnection && _textInputConnection.imeRequired()) {
+                var localPos = renderEditable.getLocalRectForCaret(_value.selection.basePos).bottomLeft;
+                return renderEditable.localToGlobal(localPos);
+            }
+
+            return null;
+        }
+        void _updateImePosIfNeed() {
+            if (!_hasInputConnection || !_textInputConnection.imeRequired()) {
+                return;
+            }
+
+            if (_imePosUpdateScheduled) {
+                return;
+            }
+
+            _imePosUpdateScheduled = true;
+            SchedulerBinding.instance.addPostFrameCallback(_ => {
+                _imePosUpdateScheduled = false;
+                if (!_hasInputConnection) {
+                    return;
+                }
+
+                _textInputConnection.setIMEPos(_getImePos());
+            });
+        }
         
     }
     
         public readonly float? cursorWidth;
         public readonly Radius cursorRadius;
         public readonly Offset cursorOffset;
-        public readonly ui.BoxHeightStyle selectionHeightStyle;
-        public readonly ui.BoxWidthStyle selectionWidthStyle;
+        public readonly BoxHeightStyle selectionHeightStyle;
+        public readonly BoxWidthStyle selectionWidthStyle;
         public readonly bool enableInteractiveSelection;
         public readonly TextSelectionDelegate textSelectionDelegate;
         public readonly bool? paintCursorAboveText;
             Radius cursorRadius = null,
             Offset cursorOffset = null,
             bool? paintCursorAboveText = null,
-            ui.BoxHeightStyle selectionHeightStyle = ui.BoxHeightStyle.tight,
-            ui.BoxWidthStyle selectionWidthStyle = ui.BoxWidthStyle.tight,
+            BoxHeightStyle selectionHeightStyle = BoxHeightStyle.tight,
+            BoxWidthStyle selectionWidthStyle = BoxWidthStyle.tight,
             bool enableInteractiveSelection = true,
             TextSelectionDelegate textSelectionDelegate = null,
             float? devicePixelRatio = null

engine/src/lib/ui/window/pointer_data.h

     kDown,
     kMove,
     kUp,
+    kMouseDown,
+    kMouseUp,
   };
 
   enum class DeviceKind : int64_t {
-    kInvertedStylus,
+    kInvertedStylus,    
+    kKeyboard,
   };
 
   enum class SignalKind : int64_t {

engine/src/shell/platform/embedder/embedder.cc

       return PointerData::Change::kRemove;
     case kHover:
       return PointerData::Change::kHover;
+    case kMouseDown:
+      return PointerData::Change::kMouseDown;
+    case kMouseUp:
+      return PointerData::Change::kMouseUp;
   }
   return PointerData::Change::kCancel;
 }
       return PointerData::DeviceKind::kMouse;
     case kUIWidgetsPointerDeviceKindTouch:
       return PointerData::DeviceKind::kTouch;
+    case kUIWidgetsPointerDeviceKindKeyboard:
+      return PointerData::DeviceKind::kKeyboard;
   }
   return PointerData::DeviceKind::kMouse;
 }

engine/src/shell/platform/embedder/embedder.h

   kAdd,
   kRemove,
   kHover,
+  kMouseDown,
+  kMouseUp,
+  kUIWidgetsPointerDeviceKindTouch = 0,
-  kUIWidgetsPointerDeviceKindTouch,
+  kUIWidgetsPointerDeviceKindKeyboard = 7,
 } UIWidgetsPointerDeviceKind;
 
 typedef enum {

engine/src/shell/platform/unity/windows/uiwidgets_panel.cc

   }
 }
 
+void UIWidgetsPanel::OnKeyDown(int keyCode, bool isKeyDown) {
+  if (process_events_) {
+    UIWidgetsPointerEvent event = {};
+    event.phase = isKeyDown ? UIWidgetsPointerPhase::kMouseDown : UIWidgetsPointerPhase::kMouseUp;
+    event.device_kind =
+        UIWidgetsPointerDeviceKind::kUIWidgetsPointerDeviceKindKeyboard;
+    event.buttons = keyCode;
+    event.struct_size = sizeof(event);
+    event.timestamp =
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::high_resolution_clock::now().time_since_epoch())
+            .count();
+
+    UIWidgetsEngineSendPointerEvent(engine_, &event, 1);
+  }
+}
+
 void UIWidgetsPanel::OnMouseMove(float x, float y) {
   if (process_events_) {
     SendMouseMove(x, y);
 UIWIDGETS_API(void)
 UIWidgetsPanel_unregisterTexture(UIWidgetsPanel* panel, int texture_id) {
   panel->UnregisterTexture(texture_id);
+}
+
+
+UIWIDGETS_API(void)
+UIWidgetsPanel_onKey(UIWidgetsPanel* panel, int keyCode, bool isKeyDown) {
+  panel->OnKeyDown(keyCode, isKeyDown);
 }
 
 UIWIDGETS_API(void)

engine/src/shell/platform/unity/windows/uiwidgets_panel.h

   void ProcessVSync();
 
   void VSyncCallback(intptr_t baton);
+  
+  void OnKeyDown(int keyCode, bool isKeyDown);
 
   void OnMouseMove(float x, float y);
 

Samples/UIWidgetsSamples_2019_4/Assets/Scene/TextFeild.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 &764046566
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 764046568}
+  - component: {fileID: 764046567}
+  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 &764046567
+Light:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 764046566}
+  m_Enabled: 1
+  serializedVersion: 10
+  m_Type: 1
+  m_Shape: 0
+  m_Color: {r: 1, g: 1, b: 1, 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 &764046568
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 764046566}
+  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 &847097468
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 847097469}
+  - component: {fileID: 847097471}
+  - component: {fileID: 847097470}
+  m_Layer: 5
+  m_Name: RawImage
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &847097469
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 847097468}
+  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: 2122288190}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &847097470
+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: 0a0d26c35b9d38d4f9cb26d890a0cedb, 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:
+  - family: CupertinoIcons
+    fonts:
+    - asset: CupertinoIcons.ttf
+      weight: 0
+  hardwareAntiAliasing: 0
+--- !u!222 &847097471
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 847097468}
+  m_CullTransparentMesh: 0
+--- !u!1 &1548023132
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1548023135}
+  - component: {fileID: 1548023134}
+  - component: {fileID: 1548023133}
+  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 &1548023133
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1548023132}
+  m_Enabled: 1
+--- !u!20 &1548023134
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1548023132}
+  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: 1
+  orthographic size: 5.6
+  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 &1548023135
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1548023132}
+  m_LocalRotation: {x: 0, y: 0.7071068, z: -0.7071068, w: 0}
+  m_LocalPosition: {x: 0, y: 1, z: 0.32}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 90, y: 180, z: 0}
+--- !u!1 &1900497009
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1900497012}
+  - component: {fileID: 1900497011}
+  - component: {fileID: 1900497010}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1900497010
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1900497009}
+  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 &1900497011
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1900497009}
+  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 &1900497012
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1900497009}
+  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 &2122288186
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2122288190}
+  - component: {fileID: 2122288189}
+  - component: {fileID: 2122288188}
+  - component: {fileID: 2122288187}
+  m_Layer: 5
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &2122288187
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2122288186}
+  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 &2122288188
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2122288186}
+  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 &2122288189
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2122288186}
+  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 &2122288190
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2122288186}
+  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: 847097469}
+  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}

Samples/UIWidgetsSamples_2019_4/Assets/Scene/TextFeild.unity.meta

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

Samples/UIWidgetsSamples_2019_4/Assets/Script/TextFieldTest.cs

+using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.widgets;
+using ui_ = Unity.UIWidgets.widgets.ui_;
+using Unity.UIWidgets.cupertino;
+
+namespace UIWidgetsSample
+{
+    public class TextFieldTest : 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 HomeScreen() 
+                );
+            }
+        }
+
+        class HomeScreen : StatelessWidget
+        {
+            public override Widget build(BuildContext context)
+            {
+                return new HomeScreen3();
+            }
+        }
+
+        public class HomeScreen3 : StatelessWidget
+        {
+            public override Widget build(BuildContext context)
+            {
+                return new CupertinoPageScaffold(
+                    child: new Center(
+                        child:
+                        new Container(
+                            width: 200,
+                            child: new MyPrefilledText()
+                        )
+                    )
+                );
+            }
+        }
+
+
+        public class MyPrefilledText : StatefulWidget
+        {
+            public override State createState() => new _MyPrefilledTextState();
+        }
+
+        class _MyPrefilledTextState : State<MyPrefilledText>
+        {
+            TextEditingController _textController;
+
+            public override void initState()
+            {
+                base.initState();
+                _textController = new TextEditingController(text: "initial text");
+            }
+
+            public override Widget build(BuildContext context)
+            {
+                return new CupertinoTextField(controller: _textController);
+            }
+        }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/TextFieldSample.cs

+using Unity.UIWidgets.material;
+using Unity.UIWidgets.painting;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEngine;
+using ui_ = Unity.UIWidgets.widgets.ui_;
+
+namespace UIWidgetsSample
+{
+    public class TextFieldSample : UIWidgetsSamplePanel
+    {
+        protected override void main()
+        {
+            ui_.runApp(
+                new MaterialApp(
+                    title: "Text Fields",
+                    home: new MyCustomForm()
+                )
+            );
+        }
+
+        protected new void OnEnable()
+        {
+            base.OnEnable();
+            // TODO: add font
+            // FontManager.instance.addFont(Resources.Load<Font>(path: "fonts/MaterialIcons-Regular"), "Material Icons");
+        }
+    }
+
+    class MyCustomForm : StatefulWidget
+    {
+        public override State createState()
+        {
+            return new _MyCustomFormState();
+        }
+    }
+
+    class _MyCustomFormState : State<MyCustomForm>
+    {
+        readonly TextEditingController myController = new TextEditingController();
+
+        public override void dispose()
+        {
+            this.myController.dispose();
+            base.dispose();
+        }
+
+        public override Widget build(BuildContext context)
+        {
+            return new Scaffold(
+                appBar: new AppBar(
+                    title: new Text("Retrieve Text Input")
+                ),
+                body: new Padding(
+                    padding: EdgeInsets.all(16.0f)
+                    ,
+                    child: new TextField(
+                        controller: this.myController,
+                        autofocus: true,
+                        decoration: new InputDecoration(
+                            hintText: "hinthere",
+                            labelText: "pwd",
+                            prefixIcon: new Icon(Unity.UIWidgets.material.Icons.search)
+                        )
+                    )
+                ),
+                floatingActionButton: new FloatingActionButton(
+                    // When the user presses the button, show an alert dialog with the
+                    // text the user has typed into our text field.
+                    onPressed: () =>
+                    {
+                        material_.showDialog<object>(
+                            context: context,
+                            builder: (_context) =>
+                            {
+                                return new AlertDialog(
+                                    // Retrieve the text the user has typed in using our
+                                    // TextEditingController
+                                    content: new Text(this.myController.text)
+                                );
+                            });
+                    },
+                    tooltip: "Show me the value",
+                    child: new Icon(Icons.search)
+                )
+            );
+        }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/TextFieldSample.cs.meta

+fileFormatVersion: 2
+guid: d8495746441674d418f8093fdd93c7ac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/TextInputSample.cs

+using System.Collections.Generic;
+using uiwidgets;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.material;
+using Unity.UIWidgets.painting;
+using Unity.UIWidgets.rendering;
+using Unity.UIWidgets.service;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEngine;
+using Color = Unity.UIWidgets.ui.Color;
+using TextStyle = Unity.UIWidgets.painting.TextStyle;
+using ui_ = Unity.UIWidgets.widgets.ui_;
+
+namespace UIWidgetsSample
+{
+    public class TextInputSample : UIWidgetsSamplePanel
+    {
+        protected override void main()
+        {
+            ui_.runApp(
+                new MaterialApp(
+                    home: new EditableInputTypeWidget()
+                )
+            );
+        }
+
+        protected new void OnEnable()
+        {
+            base.OnEnable();
+        }
+
+        class _TextInputSample : StatefulWidget
+        {
+            public readonly string title;
+
+            public _TextInputSample(Key key = null, string title = null) : base(key)
+            {
+                this.title = title;
+            }
+
+            public override State createState()
+            {
+                return new _TextInputSampleState();
+            }
+        }
+
+        class _TextInputSampleState : State<_TextInputSample>
+        {
+            TextEditingController titleController = new TextEditingController("");
+            TextEditingController descController = new TextEditingController("");
+            FocusNode _titleFocusNode;
+            FocusNode _descFocusNode;
+
+            public override void initState()
+            {
+                base.initState();
+                this._titleFocusNode = new FocusNode();
+                this._descFocusNode = new FocusNode();
+            }
+
+            public override void dispose()
+            {
+                this._titleFocusNode.dispose();
+                this._descFocusNode.dispose();
+                base.dispose();
+            }
+
+            Widget title()
+            {
+                return new Container(child: new Text(this.widget.title ?? "", textAlign: TextAlign.center,
+                        style: new TextStyle(fontSize: 24, fontWeight: FontWeight.w700)),
+                    margin: EdgeInsets.only(bottom: 20));
+            }
+
+            Widget titleInput()
+            {
+                return new Row(
+                    children: new List<Widget>(
+                    )
+                    {
+                        new SizedBox(width: 100, child: new Text("Title")),
+                        new Flexible(child: new Container(
+                            decoration: new BoxDecoration(border: Border.all(new Color(0xFF000000), 1)),
+                            padding: EdgeInsets.fromLTRB(8, 0, 8, 0),
+                            child: new EditableText(maxLines: 1,
+                                controller: this.titleController,
+                                selectionControls: MaterialUtils.materialTextSelectionControls,
+                                backgroundCursorColor: Colors.transparent,
+                                autofocus: true,
+                                focusNode: new FocusNode(),
+                                style: new TextStyle(
+                                    fontSize: 18,
+                                    height: 1.5f,
+                                    color: new Color(0xFF1389FD)
+                                ),
+                                selectionColor: Color.fromARGB(255, 255, 0, 0),
+                                cursorColor: Color.fromARGB(255, 0, 0, 0))
+                        )),
+                    }
+                );
+            }
+
+            Widget descInput()
+            {
+                return new Container(
+                    margin: EdgeInsets.fromLTRB(0, 10, 0, 10),
+                    child: new Row(
+                        children: new List<Widget>(
+                        )
+                        {
+                            new SizedBox(width: 100, child: new Text("Description")),
+                            new Flexible(child: new Container(
+                                height: 200,
+                                decoration: new BoxDecoration(border: Border.all(new Color(0xFF000000), 1)),
+                                padding: EdgeInsets.fromLTRB(8, 0, 8, 0),
+                                child: new EditableText(maxLines: 200,
+                                    controller: this.descController,
+                                    backgroundCursorColor: Colors.transparent,
+                                    selectionControls: MaterialUtils.materialTextSelectionControls,
+                                    focusNode: new FocusNode(),
+                                    style: new TextStyle(
+                                        fontSize: 18,
+                                        height: 1.5f,
+                                        color: new Color(0xFF1389FD)
+                                    ),
+                                    selectionColor: Color.fromARGB(255, 255, 0, 0),
+                                    cursorColor: Color.fromARGB(255, 0, 0, 0))
+                            )),
+                        }
+                    ));
+            }
+
+            public override Widget build(BuildContext context)
+            {
+                var container = new Container(
+                    padding: EdgeInsets.all(10),
+                    decoration: new BoxDecoration(color: new Color(0x7F000000),
+                        border: Border.all(color: Color.fromARGB(255, 255, 0, 0), width: 5),
+                        borderRadius: BorderRadius.all(2)),
+                    child: new Column(
+                        crossAxisAlignment: CrossAxisAlignment.stretch,
+                        children: new List<Widget>
+                        {
+                            this.title(),
+                            this.titleInput(),
+                            this.descInput(),
+                        }
+                    )
+                );
+                return container;
+            }
+        }
+    }
+
+    public class EditableInputTypeWidget : StatefulWidget
+    {
+        public EditableInputTypeWidget(Key key = null) : base(key)
+        {
+        }
+
+        public override State createState()
+        {
+            return new _EditableInputTypeWidgetState();
+        }
+    }
+
+    class _EditableInputTypeWidgetState : State<EditableInputTypeWidget>
+    {
+        Widget rowWidgets(string title, Widget widget)
+        {
+            return new Container(
+                height: 80,
+                child: new Row(
+                    children: new List<Widget>
+                    {
+                        new Container(width: 100,
+                            child: new Text(title,
+                                style: new TextStyle(fontSize: 14, height: 2.0f, color: Colors.black,
+                                    decoration: TextDecoration.none))),
+                        new Flexible(child: new Container(child: widget, padding: EdgeInsets.all(4), decoration:
+                            new BoxDecoration(border: Border.all(color: Color.black))))
+                    }
+                ));
+        }
+
+        void textSubmitted(string text)
+        {
+            Debug.Log($"text submitted {text}");
+        }
+
+        List<Widget> buildInputs(bool unityKeyboard)
+        {
+            List<Widget> widgets = new List<Widget>();
+            var style = new TextStyle();
+            var cursorColor = new Color(0xFF000000);
+            var selectionColor = new Color(0xFF6F6F6F);
+
+            widgets.Add(this.rowWidgets("Default", new EditStateProvider(builder: ((buildContext, controller, node) =>
+                new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                    backgroundCursorColor: Colors.blue,
+                    selectionColor: selectionColor, onSubmitted: this.textSubmitted
+                    , unityTouchKeyboard: unityKeyboard,
+                    selectionControls: MaterialUtils.materialTextSelectionControls,
+                    cursorWidth: 5.0f, cursorRadius: Radius.circular(2.5f), cursorOpacityAnimates: true,
+                    paintCursorAboveText: true)))));
+
+            widgets.Add(this.rowWidgets("Multiple Line", new EditStateProvider(
+                builder: ((buildContext, controller, node) =>
+                    new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                        backgroundCursorColor: Colors.transparent,
+                        selectionColor: selectionColor, maxLines: 4,
+                        onSubmitted: this.textSubmitted, unityTouchKeyboard: unityKeyboard,
+                        selectionControls: MaterialUtils.materialTextSelectionControls
+                        // ,
+                        // globalKeyEventHandler: (evt, enableCustomAction) => {
+                        //     //customized key event handler which may swallow input keys to the editable and 
+                        //     //perform customized functionality
+                        //     //
+                        //     //evt is the input rawKeyEvent
+                        //     //you should perform any customized functionality within the closure of "if(enableCustomAction) {}", 
+                        //     //otherwise it could be performed multiple times for a single key event.
+                        //     //
+                        //     //Very Important: for any input event, please ensure that all the output RawInputKeyResponse is the same
+                        //     //regardless of the value of enableCustomAction, otherwise the behavior of this handler would become
+                        //     //wrong and unpredictable
+                        //     if (evt.data.unityEvent.keyCode == KeyCode.UpArrow) {
+                        //         if (enableCustomAction) {
+                        //             Debug.Log("UpUpUp");
+                        //         }
+                        //
+                        //         return RawInputKeyResponse.swallowResponse;
+                        //     }
+                        //
+                        //     if (evt.data.unityEvent.keyCode == KeyCode.DownArrow) {
+                        //         if (enableCustomAction) {
+                        //             Debug.Log("UpUpUp");
+                        //         }
+                        //
+                        //         return RawInputKeyResponse.swallowResponse;
+                        //     }
+                        //
+                        //     if (evt.data.unityEvent.character == '\n' ||
+                        //         evt.data.unityEvent.character == '\r' ||
+                        //         evt.data.unityEvent.character == 3 ||
+                        //         evt.data.unityEvent.character == 10) {
+                        //
+                        //         if (evt.data.unityEvent.shift) {
+                        //             if (enableCustomAction) {
+                        //                 Debug.Log("shift return >>>");
+                        //             }
+                        //             return new RawInputKeyResponse(true, evt.data.unityEvent.character, inputAction: TextInputAction.newline);
+                        //         }
+                        //         else {
+                        //             if (enableCustomAction) {
+                        //                 Debug.Log("send !!!!");
+                        //             }
+                        //             return RawInputKeyResponse.swallowResponse;
+                        //         }
+                        //     }
+                        //                 
+                        //     return RawInputKeyResponse.convert(evt);
+                        // }
+                    )))));
+
+            widgets.Add(this.rowWidgets("ObscureText", new EditStateProvider(
+                builder: ((buildContext, controller, node) =>
+                    new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                        backgroundCursorColor: Colors.transparent,
+                        selectionColor: selectionColor, obscureText: true,
+                        onSubmitted: this.textSubmitted, unityTouchKeyboard: unityKeyboard,
+                        selectionControls: MaterialUtils.materialTextSelectionControls)))));
+
+            widgets.Add(this.rowWidgets("Number", new EditStateProvider(builder: ((buildContext, controller, node) =>
+                new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                    backgroundCursorColor: Colors.transparent,
+                    selectionColor: selectionColor, keyboardType: TextInputType.number,
+                    onSubmitted: this.textSubmitted, unityTouchKeyboard: unityKeyboard,
+                    selectionControls: MaterialUtils.materialTextSelectionControls)))));
+
+            widgets.Add(this.rowWidgets("Phone", new EditStateProvider(builder: ((buildContext, controller, node) =>
+                new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                    backgroundCursorColor: Colors.transparent,
+                    selectionColor: selectionColor, keyboardType: TextInputType.phone,
+                    onSubmitted: this.textSubmitted, unityTouchKeyboard: unityKeyboard,
+                    selectionControls: MaterialUtils.materialTextSelectionControls)))));
+
+            widgets.Add(this.rowWidgets("Email", new EditStateProvider(builder: ((buildContext, controller, node) =>
+                new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                    backgroundCursorColor: Colors.transparent,
+                    selectionColor: selectionColor, keyboardType: TextInputType.emailAddress,
+                    onSubmitted: this.textSubmitted, unityTouchKeyboard: unityKeyboard,
+                    selectionControls: MaterialUtils.materialTextSelectionControls)))));
+
+            widgets.Add(this.rowWidgets("Url", new EditStateProvider(builder: ((buildContext, controller, node) =>
+                new EditableText(controller: controller, focusNode: node, style: style, cursorColor: cursorColor,
+                    backgroundCursorColor: Colors.transparent,
+                    selectionColor: selectionColor, keyboardType: TextInputType.url,
+                    onSubmitted: this.textSubmitted, unityTouchKeyboard: unityKeyboard,
+                    selectionControls: MaterialUtils.materialTextSelectionControls)))));
+            return widgets;
+        }
+
+        public override Widget build(BuildContext context)
+        {
+            List<Widget> widgets = new List<Widget>();
+
+            widgets.Add(new Text("UIWidgets Touch Keyboard",
+                style: new TextStyle(fontSize: 20, height: 2.0f, color: Colors.black, decoration: TextDecoration.none),
+                textAlign: TextAlign.center));
+            widgets.AddRange(this.buildInputs(false));
+
+            widgets.Add(new Text("Unity Touch Keyboard",
+                style: new TextStyle(fontSize: 20, height: 2.0f, color: Colors.black, decoration: TextDecoration.none),
+                textAlign: TextAlign.center));
+            widgets.AddRange(this.buildInputs(true));
+
+            return new Container(
+                padding: EdgeInsets.all(12),
+                child: new SingleChildScrollView(child: new Column(
+                    crossAxisAlignment: CrossAxisAlignment.stretch,
+                    children: widgets)));
+        }
+    }
+
+    public class EditStateProvider : StatefulWidget
+    {
+        public delegate EditableText EditableBuilder(BuildContext context,
+            TextEditingController controller, FocusNode focusNode);
+
+        public readonly EditableBuilder builder;
+
+        public EditStateProvider(Key key = null, EditableBuilder builder = null) : base(key)
+        {
+            D.assert(builder != null);
+            this.builder = builder;
+        }
+
+        public override State createState()
+        {
+            return new _EditStateProviderState();
+        }
+    }
+
+    class _EditStateProviderState : State<EditStateProvider>
+    {
+        TextEditingController _controller;
+        FocusNode _focusNode;
+
+        public override void initState()
+        {
+            base.initState();
+            this._focusNode = new FocusNode();
+            this._controller = new TextEditingController("");
+        }
+
+
+        public override void dispose()
+        {
+            this._focusNode.dispose();
+            base.dispose();
+        }
+
+        public override Widget build(BuildContext context)
+        {
+            return this.widget.builder(context, this._controller, this._focusNode);
+        }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/TextInputSample.cs.meta

+fileFormatVersion: 2
+guid: aadc2d983f1b0564688e35a7d4933599
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/ToDoAppSample.cs

+using System.Collections.Generic;
+using System.Linq;
+using uiwidgets;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
+using Unity.UIWidgets.material;
+using Unity.UIWidgets.painting;
+using Unity.UIWidgets.rendering;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEngine;
+using Color = Unity.UIWidgets.ui.Color;
+using TextStyle = Unity.UIWidgets.painting.TextStyle;
+using Texture = Unity.UIWidgets.widgets.Texture;
+using ui_ = Unity.UIWidgets.widgets.ui_;
+
+namespace UIWidgetsSample
+{
+    public class ToDoAppSample : UIWidgetsSamplePanel
+    {
+        protected override void main()
+        {
+            ui_.runApp(
+                new WidgetsApp(
+                    home: new ToDoListApp(),
+                    pageRouteBuilder: this.pageRouteBuilder)
+            );
+        }
+
+        protected new void OnEnable()
+        {
+            base.OnEnable();
+        }
+
+        public class ToDoListApp : StatefulWidget
+        {
+            public ToDoListApp(Key key = null) : base(key)
+            {
+            }
+
+            public override State createState()
+            {
+                return new _ToDoListAppState();
+            }
+        }
+
+        public class CustomButton : StatelessWidget
+        {
+            public CustomButton(
+                Key key = null,
+                GestureTapCallback onPressed = null,
+                EdgeInsets padding = null,
+                Color backgroundColor = null,
+                Widget child = null
+            ) : base(key: key)
+            {
+                this.onPressed = onPressed;
+                this.padding = padding ?? EdgeInsets.all(8.0f);
+                this.backgroundColor = backgroundColor ?? Colors.transparent;
+                this.child = child;
+            }
+
+            public readonly GestureTapCallback onPressed;
+            public readonly EdgeInsets padding;
+            public readonly Widget child;
+            public readonly Color backgroundColor;
+
+            public override Widget build(BuildContext context)
+            {
+                return new GestureDetector(
+                    onTap: this.onPressed,
+                    child: new Container(
+                        padding: this.padding,
+                        color: this.backgroundColor,
+                        child: this.child
+                    )
+                );
+            }
+        }
+
+        class _ToDoListAppState : State<ToDoListApp>
+        {
+            public class ToDoItem
+            {
+                public int id;
+                public string content;
+            }
+
+            List<ToDoItem> items = new List<ToDoItem>();
+            int nextId = 0;
+            TextEditingController controller = new TextEditingController("");
+            FocusNode _focusNode;
+
+            public override void initState()
+            {
+                base.initState();
+                this._focusNode = new FocusNode();
+            }
+
+            public override void dispose()
+            {
+                this._focusNode.dispose();
+                base.dispose();
+            }
+
+            Widget title()
+            {
+                return new Text("ToDo App", textAlign: TextAlign.center,
+                    style: new TextStyle(fontSize: 30, fontWeight: FontWeight.w700));
+            }
+
+            Widget textInput()
+            {
+                return new Container(
+                    child: new Row(
+                        mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                        children: new List<Widget>(
+                        )
+                        {
+                            new Container(
+                                width: 300,
+                                decoration: new BoxDecoration(border: Border.all(new Color(0xFF000000), 1)),
+                                padding: EdgeInsets.fromLTRB(8, 0, 8, 0),
+                                child: new EditableText(maxLines: 1,
+                                    controller: this.controller,
+                                    onSubmitted: (text) =>
+                                    {
+                                        this.controller.clear();
+                                        this._addItem(text);
+                                    },
+                                    selectionControls: MaterialUtils.materialTextSelectionControls,
+                                    backgroundCursorColor: Colors.red,
+                                    autofocus: true,
+                                    focusNode: new FocusNode(),
+                                    style: new TextStyle(
+                                        fontSize: 18,
+                                        height: 1.5f,
+                                        color: new Color(0xFF1389FD)
+                                    ),
+                                    selectionColor: Color.fromARGB(255, 255, 0, 0),
+                                    cursorColor: Color.fromARGB(255, 0, 0, 0))
+                            ),
+
+                            new CustomButton(backgroundColor: Color.fromARGB(255, 0, 204, 204),
+                                padding: EdgeInsets.all(10),
+                                child: new Text("Add", style: new TextStyle(
+                                    fontSize: 20, color: Color.fromARGB(255, 255, 255, 255), fontWeight: FontWeight.w700
+                                )), onPressed: () => { this._addItem(); })
+                        }
+                    )
+                );
+            }
+
+            void _addItem(string text = null)
+            {
+                this.setState(() =>
+                {
+                    text = text ?? this.controller.text;
+                    if (text != "")
+                    {
+                        this.items.Add(new ToDoItem()
+                            {id = this.nextId++, content = text});
+                    }
+                });
+            }
+
+            Widget contents()
+            {
+                var children = this.items.Select((item) =>
+                {
+                    return (Widget) new Text(
+                        item.content, style: new TextStyle(
+                            fontSize: 18,
+                            height: 1.5f
+                        )
+                    );
+                });
+                return new Flexible(
+                    child: new ListView(
+                        physics: new AlwaysScrollableScrollPhysics(),
+                        children: children.ToList()
+                    )
+                );
+            }
+
+            public override Widget build(BuildContext context)
+            {
+                var container = new Container(
+                    padding: EdgeInsets.all(10),
+                    decoration: new BoxDecoration(color: new Color(0x7F000000),
+                        border: Border.all(color: Color.fromARGB(255, 255, 0, 0), width: 5),
+                        borderRadius: BorderRadius.all(2)),
+                    child: new Column(
+                        crossAxisAlignment: CrossAxisAlignment.stretch,
+                        children: new List<Widget>
+                        {
+                            this.title(),
+                            this.textInput(),
+                            //      textInput(),
+                            this.contents(),
+                            // this.videoTexture(),
+                        }
+                    )
+                );
+                return container;
+            }
+        }
+    }
+
+    public class CustomButton : StatelessWidget
+    {
+        public CustomButton(
+            Key key = null,
+            GestureTapCallback onPressed = null,
+            EdgeInsets padding = null,
+            Color backgroundColor = null,
+            Widget child = null
+        ) : base(key: key)
+        {
+            this.onPressed = onPressed;
+            this.padding = padding ?? EdgeInsets.all(8.0f);
+            this.backgroundColor = backgroundColor ?? Colors.transparent;
+            this.child = child;
+        }
+
+        public readonly GestureTapCallback onPressed;
+        public readonly EdgeInsets padding;
+        public readonly Widget child;
+        public readonly Color backgroundColor;
+
+        public override Widget build(BuildContext context)
+        {
+            return new GestureDetector(
+                onTap: this.onPressed,
+                child: new Container(
+                    padding: this.padding,
+                    color: this.backgroundColor,
+                    child: this.child
+                )
+            );
+        }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/ToDoAppSample.cs.meta

+fileFormatVersion: 2
+guid: bb50d118c9f001e4c85c81a6ce1393c2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/UIWidgetsSamplePanel.cs

+using Unity.UIWidgets.animation;
+using Unity.UIWidgets.engine;
+using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.widgets;
+
+namespace UIWidgetsSample {
+    public class UIWidgetsSamplePanel: UIWidgetsPanel {
+        
+        protected virtual PageRouteFactory pageRouteBuilder {
+            get {
+                return (RouteSettings settings, WidgetBuilder builder) =>
+                    new PageRouteBuilder(
+                        settings: settings,
+                        pageBuilder: (BuildContext context, Animation<float> animation,
+                            Animation<float> secondaryAnimation) => builder(context)
+                    );
+            }
+        }
+
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/UIWidgetsSamplePanel.cs.meta

+fileFormatVersion: 2
+guid: 5b99d50c937b4f4458f3418b4f599076
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: