Prepare for publishing to Package Manager

README-ZH.md

@@ -262,7 +262,6 @@ EmojiUtils.configuration = new EmojiResourceConfiguration(
 
 我们提供了一个包装好的`UnityObjectDetector`组件以及`onRelease`回调函数，借此您可以实现简单地将物体（例如Hierarchy内的场景物体、Project窗口下的文件等）拖拽至区域内，来获得`UnityEngine.Object[] `类型的引用并进行操作。
 
-
 ## 调试UIWidgets应用程序
 
 #### 定义UIWidgets_DEBUG

README.md

@@ -298,7 +298,6 @@ EmojiUtils.configuration = new EmojiResourceConfiguration(
 
 With the provided packaged stateful widget `UnityObjectDetector` and its `onRelease` callback function, you can easily drag some objects (for example GameObject from Hierarchy, files from Project Window, etc) into the area, get the UnityEngine.Object[] references and make further modification.
 
-
 ## Debug UIWidgets Application
 
 #### Define UIWidgets_DEBUG

Runtime/debugger/inspector_window.cs

@@ -45,7 +45,7 @@ public class WidgetsInpsectorWindow : EditorWindow {
 
         List<Action> m_UpdateActions = new List<Action>();
 
-        [MenuItem("Window/Analysis/UIWidgets Inspector")]
+        [MenuItem("Window/UIWidgets/Inspector")]
         public static void Init() {
             WidgetsInpsectorWindow window =
                 (WidgetsInpsectorWindow) GetWindow(typeof(WidgetsInpsectorWindow));

Runtime/editor/UIWidgetsResourcesImporter.cs

@@ -0,0 +1,139 @@
+#if UNITY_EDITOR
+using UnityEngine.Serialization;
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+
+namespace Unity.UIWidgets.editor
+{
+    [System.Serializable]
+    public class UIWidgetsResourcesImporter
+    {
+        bool m_UIWidgetsResourcesImported;
+
+        public void OnDestroy()
+        {
+        }
+
+        public void OnGUI()
+        {
+            string packageFullPath = GetPackageFullPath();
+            m_UIWidgetsResourcesImported = Directory.Exists("Assets/UIWidgetsResources") ||
+                                           Directory.Exists(packageFullPath + "/Runtime/Resources/fonts");
+            // Display options to import Essential resources
+            GUILayout.BeginVertical(EditorStyles.helpBox);
+            {
+                GUILayout.Label("UIWidgets Resources", EditorStyles.boldLabel);
+                GUILayout.Label("We need to add resources to your project that are essential for using UIWidgets. " +
+                                "These new resources will be placed at the root of your project in the \"UIWidgetsResources\" folder.",
+                    new GUIStyle(EditorStyles.label) { wordWrap = true } );
+                GUILayout.Space(5f);
+
+                GUI.enabled = !m_UIWidgetsResourcesImported;
+                if (GUILayout.Button("Import UIWidgets Resources"))
+                {
+                    AssetDatabase.importPackageCompleted += ImportCallback;
+
+                    AssetDatabase.ImportPackage(packageFullPath + "/Package Resources/UIWidgetsResources.unitypackage", false);
+                }
+                GUILayout.Space(5f);
+                GUI.enabled = true;
+            }
+            GUILayout.EndVertical();
+            GUILayout.Space(5f);
+        }
+
+        internal void RegisterResourceImportCallback()
+        {
+            AssetDatabase.importPackageCompleted += ImportCallback;
+        }
+
+        void ImportCallback(string packageName)
+        {
+            if (packageName == "UIWidgetsResources")
+            {
+                m_UIWidgetsResourcesImported = true;
+
+                #if UNITY_2018_3_OR_NEWER
+                SettingsService.NotifySettingsProviderChanged();
+                #endif
+            }
+
+            Debug.Log("[" + packageName + "] have been imported.");
+
+            AssetDatabase.importPackageCompleted -= ImportCallback;
+        }
+
+        static string GetPackageFullPath()
+        {
+            string packagePath = Path.GetFullPath("Packages/com.unity.uiwidgets");
+            if (Directory.Exists(packagePath))
+            {
+                return packagePath;
+            }
+
+            packagePath = Path.GetFullPath("Packages/UIWidgets");
+            if (Directory.Exists(packagePath))
+            {
+                return packagePath;
+            }
+
+            packagePath = Path.GetFullPath("Assets/UIWidgets");
+            if (Directory.Exists(packagePath))
+            {
+                return packagePath;
+            }
+
+            return null;
+        }
+    }
+
+    public class UIWidgetsResourcesImporterWindow : EditorWindow
+    {
+        [FormerlySerializedAs("m_ResourceImporter")] [SerializeField]
+        UIWidgetsResourcesImporter resourcesImporter;
+
+        public static void ShowResourcesImporterWindow()
+        {
+            var window = GetWindow<UIWidgetsResourcesImporterWindow>();
+            window.titleContent = new GUIContent("UIWidgets Resources Importer");
+            window.Focus();
+        }
+
+        void OnEnable()
+        {
+            SetEditorWindowSize();
+
+            if (resourcesImporter == null)
+                resourcesImporter = new UIWidgetsResourcesImporter();
+            resourcesImporter.RegisterResourceImportCallback();
+        }
+
+        void OnDestroy()
+        {
+            resourcesImporter.OnDestroy();
+        }
+
+        void OnGUI()
+        {
+            resourcesImporter.OnGUI();
+        }
+
+        void OnInspectorUpdate()
+        {
+            Repaint();
+        }
+
+        void SetEditorWindowSize()
+        {
+            EditorWindow editorWindow = this;
+
+            Vector2 windowSize = new Vector2(640, 110);
+            editorWindow.minSize = windowSize;
+            editorWindow.maxSize = windowSize;
+        }
+    }
+
+}
+
+#endif

Runtime/engine/UIWidgetsPanel.cs

@@ -138,6 +138,13 @@ void _handleViewMetricsChanged(string method, List<JSONNode> args) {
             this._displayMetrics.onViewMetricsChanged();
         }
 
+        protected virtual void InitWindowAdapter() {
+            D.assert(this._windowAdapter == null);
+            this._windowAdapter = new UIWidgetWindowAdapter(this);
+
+            this._windowAdapter.OnEnable();
+        }
+
         protected override void OnEnable() {
             base.OnEnable();
 
@@ -153,10 +160,7 @@ protected override void OnEnable() {
                 _repaintEvent = new Event {type = EventType.Repaint};
             }
 
-            D.assert(this._windowAdapter == null);
-            this._windowAdapter = new UIWidgetWindowAdapter(this);
-
-            this._windowAdapter.OnEnable();
+            this.InitWindowAdapter();
 
             Widget root;
             using (this._windowAdapter.getScope()) {

Runtime/engine/raycastable/RaycastManager.cs

@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.ui;
+using UnityEngine;
+
+namespace Unity.UIWidgets.engine.raycast {
+    public class RaycastableRect {
+        bool _isDirty = true;
+
+        public bool isDirty {
+            get { return this._isDirty; }
+        }
+
+        public float left;
+        public float right;
+        public float top;
+        public float bottom;
+
+        public void MarkDirty() {
+            this._isDirty = true;
+        }
+
+        public void UnmarkDirty() {
+            this._isDirty = false;
+        }
+
+        public void UpdateRect(float left, float top, float width, float height) {
+            this.left = left;
+            this.right = left + width;
+            this.top = top;
+            this.bottom = top + height;
+        }
+
+        public bool CheckInRect(Vector2 pos) {
+            return pos.x >= this.left &&
+                   pos.x < this.right &&
+                   pos.y >= this.top &&
+                   pos.y < this.bottom;
+        }
+    }
+
+    public class RaycastManager {
+        static RaycastManager _instance;
+
+        public static RaycastManager instance {
+            get {
+                if (_instance == null) {
+                    _instance = new RaycastManager();
+                }
+
+                return _instance;
+            }
+        }
+
+        public readonly Dictionary<int, Dictionary<int, RaycastableRect>> raycastHandlerMap =
+            new Dictionary<int, Dictionary<int, RaycastableRect>>();
+
+        public static void NewWindow(int windowHashCode) {
+            if (!instance.raycastHandlerMap.ContainsKey(windowHashCode)) {
+                instance.raycastHandlerMap.Add(windowHashCode, new Dictionary<int, RaycastableRect>());
+            }
+        }
+
+        public static void DisposeWindow(int windowHashCode) {
+            if (instance.raycastHandlerMap.ContainsKey(windowHashCode)) {
+                instance.raycastHandlerMap.Remove(windowHashCode);
+            }
+        }
+
+        public static void AddToList(int widgetHashCode, int windowHashCode) {
+            D.assert(instance.raycastHandlerMap.ContainsKey(windowHashCode), () =>
+                $"Raycast Handler Map doesn't contain Window {windowHashCode}, " +
+                $"Make sure using UIWidgetsRaycastablePanel instead of UIWidgetsPanel " +
+                $"while using RaycastableContainer.");
+            D.assert(!instance.raycastHandlerMap[windowHashCode].ContainsKey(widgetHashCode), () =>
+                $"Raycast Handler Map already contains Widget {widgetHashCode} at Window {windowHashCode}");
+
+            instance.raycastHandlerMap[windowHashCode][widgetHashCode] = new RaycastableRect();
+        }
+
+        public static void MarkDirty(int widgetHashCode, int windowHashCode) {
+            D.assert(instance.raycastHandlerMap.ContainsKey(windowHashCode), () =>
+                $"Raycast Handler Map doesn't contain Window {windowHashCode}");
+            D.assert(instance.raycastHandlerMap[windowHashCode].ContainsKey(widgetHashCode), () =>
+                $"Raycast Handler Map doesn't contain Widget {widgetHashCode} at Window {windowHashCode}");
+
+            instance.raycastHandlerMap[windowHashCode][widgetHashCode].MarkDirty();
+        }
+
+        public static void UpdateSizeOffset(int widgetHashCode, int windowHashCode, Size size, Offset offset) {
+            D.assert(instance.raycastHandlerMap.ContainsKey(windowHashCode), () =>
+                $"Raycast Handler Map doesn't contain Window {windowHashCode}");
+            D.assert(instance.raycastHandlerMap[windowHashCode].ContainsKey(widgetHashCode), () =>
+                $"Raycast Handler Map doesn't contain Widget {widgetHashCode} at Window {windowHashCode}");
+
+            if (instance.raycastHandlerMap[windowHashCode][widgetHashCode].isDirty) {
+                instance.raycastHandlerMap[windowHashCode][widgetHashCode]
+                    .UpdateRect(offset.dx, offset.dy, size.width, size.height);
+                instance.raycastHandlerMap[windowHashCode][widgetHashCode].UnmarkDirty();
+            }
+        }
+
+        public static void RemoveFromList(int widgetHashCode, int windowHashCode) {
+            D.assert(instance.raycastHandlerMap.ContainsKey(windowHashCode), () =>
+                $"Raycast Handler Map doesn't contain Window {windowHashCode}");
+            D.assert(instance.raycastHandlerMap[windowHashCode].ContainsKey(widgetHashCode), () =>
+                $"Raycast Handler Map doesn't contain Widget {widgetHashCode} at Window {windowHashCode}");
+
+            instance.raycastHandlerMap[windowHashCode].Remove(widgetHashCode);
+        }
+
+        public static bool CheckCastThrough(int windowHashCode, Vector2 pos) {
+            D.assert(instance.raycastHandlerMap.ContainsKey(windowHashCode), () =>
+                $"Raycast Handler Map doesn't contain Window {windowHashCode}");
+
+            foreach (var item in instance.raycastHandlerMap[windowHashCode]) {
+                if (item.Value.CheckInRect(pos)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}