Change DebugUIMenuElement

AlexanderVorobyov · AlexanderVorobyov · commit 9f3c8b2d9122 · 2024-08-26T20:30:55.000+03:00
diff --git a/Assets/UGF.DebugTools.Runtime.Tests/Resources/DebugUIMenuElement.asset b/Assets/UGF.DebugTools.Runtime.Tests/Resources/DebugUIMenuElement.asset
@@ -13,16 +13,10 @@ MonoBehaviour:
   m_Name: DebugUIMenuElement
   m_EditorClassIdentifier: 
   m_displayName: Debug Menu
-  m_elements:
-  - m_guid:
-      serializedVersion: 2
-      Hash: 0fa65e93e3ad3684183f9a1f295f2f61
-    m_asset: {fileID: 11400000, guid: 0fa65e93e3ad3684183f9a1f295f2f61, type: 2}
-  - m_guid:
-      serializedVersion: 2
-      Hash: f86c269d4588ce7458554c74e06f9b54
-    m_asset: {fileID: 11400000, guid: f86c269d4588ce7458554c74e06f9b54, type: 2}
-  - m_guid:
-      serializedVersion: 2
-      Hash: e2589b9ae1a2a1b43b869efdfc789269
-    m_asset: {fileID: 11400000, guid: e2589b9ae1a2a1b43b869efdfc789269, type: 2}
+  m_menu:
+  - m_name: Log
+    m_element: {fileID: 11400000, guid: 0fa65e93e3ad3684183f9a1f295f2f61, type: 2}
+  - m_name: Test 1
+    m_element: {fileID: 11400000, guid: f86c269d4588ce7458554c74e06f9b54, type: 2}
+  - m_name: Test 2
+    m_element: {fileID: 11400000, guid: e2589b9ae1a2a1b43b869efdfc789269, type: 2}
diff --git a/Packages/UGF.DebugTools/Editor/UI/DebugUIMenuElementAssetEditor.cs b/Packages/UGF.DebugTools/Editor/UI/DebugUIMenuElementAssetEditor.cs
@@ -1,5 +1,4 @@
 ﻿using UGF.DebugTools.Runtime.UI;
-using UGF.EditorTools.Editor.Assets;
 using UGF.EditorTools.Editor.IMGUI;
 using UGF.EditorTools.Editor.IMGUI.Scopes;
 using UnityEditor;
@@ -10,27 +9,27 @@ namespace UGF.DebugTools.Editor.UI
     internal class DebugUIMenuElementAssetEditor : UnityEditor.Editor
     {
         private SerializedProperty m_propertyDisplayName;
-        private AssetIdReferenceListDrawer m_listElements;
-        private ReorderableListSelectionDrawerByPath m_listElementsSelection;
+        private ReorderableListKeyAndValueDrawer m_listMenu;
+        private ReorderableListSelectionDrawerByPath m_listMenuSelection;
 
         private void OnEnable()
         {
             m_propertyDisplayName = serializedObject.FindProperty("m_displayName");
-            m_listElements = new AssetIdReferenceListDrawer(serializedObject.FindProperty("m_elements"));
+            m_listMenu = new ReorderableListKeyAndValueDrawer(serializedObject.FindProperty("m_menu"), "m_name", "m_element");
 
-            m_listElementsSelection = new ReorderableListSelectionDrawerByPath(m_listElements, "m_asset")
+            m_listMenuSelection = new ReorderableListSelectionDrawerByPath(m_listMenu, "m_element")
             {
                 Drawer = { DisplayTitlebar = true }
             };
 
-            m_listElements.Enable();
-            m_listElementsSelection.Enable();
+            m_listMenu.Enable();
+            m_listMenuSelection.Enable();
         }
 
         private void OnDisable()
         {
-            m_listElements.Disable();
-            m_listElementsSelection.Disable();
+            m_listMenu.Disable();
+            m_listMenuSelection.Disable();
         }
 
         public override void OnInspectorGUI()
@@ -41,8 +40,8 @@ public override void OnInspectorGUI()
 
                 EditorGUILayout.PropertyField(m_propertyDisplayName);
 
-                m_listElements.DrawGUILayout();
-                m_listElementsSelection.DrawGUILayout();
+                m_listMenu.DrawGUILayout();
+                m_listMenuSelection.DrawGUILayout();
             }
         }
     }
diff --git a/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenu.cs b/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenu.cs
@@ -0,0 +1,18 @@
+﻿using System;
+
+namespace UGF.DebugTools.Runtime.UI
+{
+    public readonly struct DebugUIMenu
+    {
+        public string Name { get; }
+        public DebugUIElement Element { get; }
+
+        public DebugUIMenu(string name, DebugUIElement element)
+        {
+            if (string.IsNullOrEmpty(name)) throw new ArgumentException("Value cannot be null or empty.", nameof(name));
+
+            Name = name;
+            Element = element ?? throw new ArgumentNullException(nameof(element));
+        }
+    }
+}
diff --git a/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenu.cs.meta b/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenu.cs.meta
diff --git a/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenuElement.cs b/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenuElement.cs
@@ -1,17 +1,17 @@
 ﻿using System;
 using System.Collections.Generic;
-using UGF.EditorTools.Runtime.Ids;
 using UnityEngine.UIElements;
 
 namespace UGF.DebugTools.Runtime.UI
 {
     public class DebugUIMenuElement : DebugUIElement
     {
         public string DisplayName { get; }
-        public IDictionary<GlobalId, DebugUIElement> Menus { get; }
-        public GlobalId Selected { get { return m_selected ?? throw new ArgumentException("Value not specified."); } }
-        public bool HasSelected { get { return m_selected != null; } }
+        public IReadOnlyList<DebugUIMenu> Menus { get; }
+        public int Selected { get { return m_selected ?? throw new ArgumentException("Value not specified."); } }
+        public bool HasSelected { get { return m_selected.HasValue; } }
 
+        public static string NoneMenuName { get; } = "None";
         public static string UssClassName { get; } = "ugf-debugtools-menu";
         public static string EnabledUssClassName { get; } = "ugf-debugtools-menu--enabled";
         public static string DisabledUssClassName { get; } = "ugf-debugtools-menu--disabled";
@@ -24,9 +24,9 @@ public class DebugUIMenuElement : DebugUIElement
 
         private readonly VisualElement m_headerContent;
         private readonly VisualElement m_bodyContent;
-        private GlobalId? m_selected;
+        private int? m_selected;
 
-        public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIElement> menus)
+        public DebugUIMenuElement(string displayName, IReadOnlyList<DebugUIMenu> menus)
         {
             if (string.IsNullOrEmpty(displayName)) throw new ArgumentException("Value cannot be null or empty.", nameof(displayName));
 
@@ -47,7 +47,7 @@ public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIEleme
             };
 
             var toggle = new Toggle();
-            var selection = new PopupField<GlobalId?>(OnSelectionCreateList(), 0, OnSelectionNameFormat, OnSelectionNameFormat);
+            var selection = new PopupField<int?>(OnSelectionCreateList(), 0, OnSelectionNameFormat, OnSelectionNameFormat);
 
             Add(header);
             Add(body);
@@ -59,11 +59,13 @@ public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIEleme
             m_headerContent.Add(new Label(DisplayName));
             m_bodyContent.Add(selection);
 
-            foreach ((_, DebugUIElement element) in Menus)
+            for (int i = 0; i < Menus.Count; i++)
             {
-                element.AddToClassList(BodyContentNotSelectedUssClassName);
+                DebugUIMenu menu = Menus[i];
 
-                m_bodyContent.Add(element);
+                menu.Element.AddToClassList(BodyContentNotSelectedUssClassName);
+
+                m_bodyContent.Add(menu.Element);
             }
 
             toggle.RegisterValueChangedCallback(OnToggle);
@@ -79,28 +81,28 @@ public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIEleme
             m_bodyContent.AddToClassList(BodyContentUssClassName);
         }
 
-        public void SetSelected(GlobalId id)
+        public void SetSelected(int index)
         {
-            if (!id.IsValid()) throw new ArgumentException("Value should be valid.", nameof(id));
+            if (index < 0 || index >= Menus.Count) throw new ArgumentOutOfRangeException(nameof(index));
 
             ClearSelected();
 
-            m_selected = id;
+            m_selected = index;
 
-            DebugUIElement element = Menus[m_selected.Value];
+            DebugUIMenu menu = Menus[m_selected.Value];
 
-            element.RemoveFromClassList(BodyContentNotSelectedUssClassName);
-            element.AddToClassList(BodyContentSelectedUssClassName);
+            menu.Element.RemoveFromClassList(BodyContentNotSelectedUssClassName);
+            menu.Element.AddToClassList(BodyContentSelectedUssClassName);
         }
 
         public bool ClearSelected()
         {
             if (m_selected.HasValue)
             {
-                DebugUIElement element = Menus[m_selected.Value];
+                DebugUIMenu menu = Menus[m_selected.Value];
 
-                element.RemoveFromClassList(BodyContentSelectedUssClassName);
-                element.AddToClassList(BodyContentNotSelectedUssClassName);
+                menu.Element.RemoveFromClassList(BodyContentSelectedUssClassName);
+                menu.Element.AddToClassList(BodyContentNotSelectedUssClassName);
 
                 m_selected = null;
                 return true;
@@ -118,7 +120,7 @@ private void OnToggle(ChangeEvent<bool> changeEvent)
             m_bodyContent.visible = changeEvent.newValue;
         }
 
-        private void OnSelectionChange(ChangeEvent<GlobalId?> changeEvent)
+        private void OnSelectionChange(ChangeEvent<int?> changeEvent)
         {
             if (changeEvent.newValue.HasValue)
             {
@@ -130,18 +132,18 @@ private void OnSelectionChange(ChangeEvent<GlobalId?> changeEvent)
             }
         }
 
-        private string OnSelectionNameFormat(GlobalId? id)
+        private string OnSelectionNameFormat(int? id)
         {
-            return id.HasValue ? Menus[id.Value].name : "None";
+            return id.HasValue ? Menus[id.Value].Name : NoneMenuName;
         }
 
-        private List<GlobalId?> OnSelectionCreateList()
+        private List<int?> OnSelectionCreateList()
         {
-            var list = new List<GlobalId?> { default };
+            var list = new List<int?> { default };
 
-            foreach ((GlobalId id, _) in Menus)
+            for (int i = 0; i < Menus.Count; i++)
             {
-                list.Add(id);
+                list.Add(i);
             }
 
             return list;
diff --git a/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenuElementAsset.cs b/Packages/UGF.DebugTools/Runtime/UI/DebugUIMenuElementAsset.cs
@@ -1,6 +1,5 @@
-﻿using System.Collections.Generic;
-using UGF.EditorTools.Runtime.Assets;
-using UGF.EditorTools.Runtime.Ids;
+﻿using System;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace UGF.DebugTools.Runtime.UI
@@ -9,24 +8,30 @@ namespace UGF.DebugTools.Runtime.UI
     public class DebugUIMenuElementAsset : DebugUIElementAsset
     {
         [SerializeField] private string m_displayName = "Debug Menu";
-        [SerializeField] private List<AssetIdReference<DebugUIElementAsset>> m_elements = new List<AssetIdReference<DebugUIElementAsset>>();
+        [SerializeField] private List<MenuData> m_menu = new List<MenuData>();
 
         public string DisplayName { get { return m_displayName; } set { m_displayName = value; } }
-        public List<AssetIdReference<DebugUIElementAsset>> Elements { get { return m_elements; } }
+        public List<MenuData> Menu { get { return m_menu; } }
 
-        protected override DebugUIElement OnBuild()
+        [Serializable]
+        public struct MenuData
         {
-            var menus = new Dictionary<GlobalId, DebugUIElement>();
+            [SerializeField] private string m_name;
+            [SerializeField] private DebugUIElementAsset m_element;
 
-            for (int i = 0; i < m_elements.Count; i++)
-            {
-                AssetIdReference<DebugUIElementAsset> reference = m_elements[i];
+            public string Name { get { return m_name; } set { m_name = value; } }
+            public DebugUIElementAsset Element { get { return m_element; } set { m_element = value; } }
+        }
 
-                DebugUIElement element = reference.Asset.Build();
+        protected override DebugUIElement OnBuild()
+        {
+            var menus = new List<DebugUIMenu>();
 
-                element.name = reference.Asset.name;
+            for (int i = 0; i < m_menu.Count; i++)
+            {
+                MenuData menu = m_menu[i];
 
-                menus.Add(reference.Guid, element);
+                menus.Add(new DebugUIMenu(menu.Name, menu.Element.Build()));
             }
 
             return new DebugUIMenuElement(m_displayName, menus);

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using UGF.DebugTools.Runtime.UI;`
`2`		`-using UGF.EditorTools.Editor.Assets;`
`3`	`2`	`using UGF.EditorTools.Editor.IMGUI;`
`4`	`3`	`using UGF.EditorTools.Editor.IMGUI.Scopes;`
`5`	`4`	`using UnityEditor;`
`@@ -10,27 +9,27 @@ namespace UGF.DebugTools.Editor.UI`
`10`	`9`	`internal class DebugUIMenuElementAssetEditor : UnityEditor.Editor`
`11`	`10`	`{`
`12`	`11`	`private SerializedProperty m_propertyDisplayName;`
`13`		`- private AssetIdReferenceListDrawer m_listElements;`
`14`		`- private ReorderableListSelectionDrawerByPath m_listElementsSelection;`
	`12`	`+ private ReorderableListKeyAndValueDrawer m_listMenu;`
	`13`	`+ private ReorderableListSelectionDrawerByPath m_listMenuSelection;`
`15`	`14`
`16`	`15`	`private void OnEnable()`
`17`	`16`	`{`
`18`	`17`	`m_propertyDisplayName = serializedObject.FindProperty("m_displayName");`
`19`		`- m_listElements = new AssetIdReferenceListDrawer(serializedObject.FindProperty("m_elements"));`
	`18`	`+ m_listMenu = new ReorderableListKeyAndValueDrawer(serializedObject.FindProperty("m_menu"), "m_name", "m_element");`
`20`	`19`
`21`		`- m_listElementsSelection = new ReorderableListSelectionDrawerByPath(m_listElements, "m_asset")`
	`20`	`+ m_listMenuSelection = new ReorderableListSelectionDrawerByPath(m_listMenu, "m_element")`
`22`	`21`	`{`
`23`	`22`	`Drawer = { DisplayTitlebar = true }`
`24`	`23`	`};`
`25`	`24`
`26`		`- m_listElements.Enable();`
`27`		`- m_listElementsSelection.Enable();`
	`25`	`+ m_listMenu.Enable();`
	`26`	`+ m_listMenuSelection.Enable();`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`private void OnDisable()`
`31`	`30`	`{`
`32`		`- m_listElements.Disable();`
`33`		`- m_listElementsSelection.Disable();`
	`31`	`+ m_listMenu.Disable();`
	`32`	`+ m_listMenuSelection.Disable();`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`public override void OnInspectorGUI()`
`@@ -41,8 +40,8 @@ public override void OnInspectorGUI()`
`41`	`40`
`42`	`41`	`EditorGUILayout.PropertyField(m_propertyDisplayName);`
`43`	`42`
`44`		`- m_listElements.DrawGUILayout();`
`45`		`- m_listElementsSelection.DrawGUILayout();`
	`43`	`+ m_listMenu.DrawGUILayout();`
	`44`	`+ m_listMenuSelection.DrawGUILayout();`
`46`	`45`	`}`
`47`	`46`	`}`
`48`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,17 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using UGF.EditorTools.Runtime.Ids;`
`4`	`3`	`using UnityEngine.UIElements;`
`5`	`4`
`6`	`5`	`namespace UGF.DebugTools.Runtime.UI`
`7`	`6`	`{`
`8`	`7`	`public class DebugUIMenuElement : DebugUIElement`
`9`	`8`	`{`
`10`	`9`	`public string DisplayName { get; }`
`11`		`- public IDictionary<GlobalId, DebugUIElement> Menus { get; }`
`12`		`- public GlobalId Selected { get { return m_selected ?? throw new ArgumentException("Value not specified."); } }`
`13`		`- public bool HasSelected { get { return m_selected != null; } }`
	`10`	`+ public IReadOnlyList<DebugUIMenu> Menus { get; }`
	`11`	`+ public int Selected { get { return m_selected ?? throw new ArgumentException("Value not specified."); } }`
	`12`	`+ public bool HasSelected { get { return m_selected.HasValue; } }`
`14`	`13`
	`14`	`+ public static string NoneMenuName { get; } = "None";`
`15`	`15`	`public static string UssClassName { get; } = "ugf-debugtools-menu";`
`16`	`16`	`public static string EnabledUssClassName { get; } = "ugf-debugtools-menu--enabled";`
`17`	`17`	`public static string DisabledUssClassName { get; } = "ugf-debugtools-menu--disabled";`
`@@ -24,9 +24,9 @@ public class DebugUIMenuElement : DebugUIElement`
`24`	`24`
`25`	`25`	`private readonly VisualElement m_headerContent;`
`26`	`26`	`private readonly VisualElement m_bodyContent;`
`27`		`- private GlobalId? m_selected;`
	`27`	`+ private int? m_selected;`
`28`	`28`
`29`		`- public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIElement> menus)`
	`29`	`+ public DebugUIMenuElement(string displayName, IReadOnlyList<DebugUIMenu> menus)`
`30`	`30`	`{`
`31`	`31`	`if (string.IsNullOrEmpty(displayName)) throw new ArgumentException("Value cannot be null or empty.", nameof(displayName));`
`32`	`32`
`@@ -47,7 +47,7 @@ public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIEleme`
`47`	`47`	`};`
`48`	`48`
`49`	`49`	`var toggle = new Toggle();`
`50`		`- var selection = new PopupField<GlobalId?>(OnSelectionCreateList(), 0, OnSelectionNameFormat, OnSelectionNameFormat);`
	`50`	`+ var selection = new PopupField<int?>(OnSelectionCreateList(), 0, OnSelectionNameFormat, OnSelectionNameFormat);`
`51`	`51`
`52`	`52`	`Add(header);`
`53`	`53`	`Add(body);`
`@@ -59,11 +59,13 @@ public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIEleme`
`59`	`59`	`m_headerContent.Add(new Label(DisplayName));`
`60`	`60`	`m_bodyContent.Add(selection);`
`61`	`61`
`62`		`- foreach ((_, DebugUIElement element) in Menus)`
	`62`	`+ for (int i = 0; i < Menus.Count; i++)`
`63`	`63`	`{`
`64`		`- element.AddToClassList(BodyContentNotSelectedUssClassName);`
	`64`	`+ DebugUIMenu menu = Menus[i];`
`65`	`65`
`66`		`- m_bodyContent.Add(element);`
	`66`	`+ menu.Element.AddToClassList(BodyContentNotSelectedUssClassName);`
	`67`	`+`
	`68`	`+ m_bodyContent.Add(menu.Element);`
`67`	`69`	`}`
`68`	`70`
`69`	`71`	`toggle.RegisterValueChangedCallback(OnToggle);`
`@@ -79,28 +81,28 @@ public DebugUIMenuElement(string displayName, IDictionary<GlobalId, DebugUIEleme`
`79`	`81`	`m_bodyContent.AddToClassList(BodyContentUssClassName);`
`80`	`82`	`}`
`81`	`83`
`82`		`- public void SetSelected(GlobalId id)`
	`84`	`+ public void SetSelected(int index)`
`83`	`85`	`{`
`84`		`- if (!id.IsValid()) throw new ArgumentException("Value should be valid.", nameof(id));`
	`86`	`+ if (index < 0 \|\| index >= Menus.Count) throw new ArgumentOutOfRangeException(nameof(index));`
`85`	`87`
`86`	`88`	`ClearSelected();`
`87`	`89`
`88`		`- m_selected = id;`
	`90`	`+ m_selected = index;`
`89`	`91`
`90`		`- DebugUIElement element = Menus[m_selected.Value];`
	`92`	`+ DebugUIMenu menu = Menus[m_selected.Value];`
`91`	`93`
`92`		`- element.RemoveFromClassList(BodyContentNotSelectedUssClassName);`
`93`		`- element.AddToClassList(BodyContentSelectedUssClassName);`
	`94`	`+ menu.Element.RemoveFromClassList(BodyContentNotSelectedUssClassName);`
	`95`	`+ menu.Element.AddToClassList(BodyContentSelectedUssClassName);`
`94`	`96`	`}`
`95`	`97`
`96`	`98`	`public bool ClearSelected()`
`97`	`99`	`{`
`98`	`100`	`if (m_selected.HasValue)`
`99`	`101`	`{`
`100`		`- DebugUIElement element = Menus[m_selected.Value];`
	`102`	`+ DebugUIMenu menu = Menus[m_selected.Value];`
`101`	`103`
`102`		`- element.RemoveFromClassList(BodyContentSelectedUssClassName);`
`103`		`- element.AddToClassList(BodyContentNotSelectedUssClassName);`
	`104`	`+ menu.Element.RemoveFromClassList(BodyContentSelectedUssClassName);`
	`105`	`+ menu.Element.AddToClassList(BodyContentNotSelectedUssClassName);`
`104`	`106`
`105`	`107`	`m_selected = null;`
`106`	`108`	`return true;`
`@@ -118,7 +120,7 @@ private void OnToggle(ChangeEvent<bool> changeEvent)`
`118`	`120`	`m_bodyContent.visible = changeEvent.newValue;`
`119`	`121`	`}`
`120`	`122`
`121`		`- private void OnSelectionChange(ChangeEvent<GlobalId?> changeEvent)`
	`123`	`+ private void OnSelectionChange(ChangeEvent<int?> changeEvent)`
`122`	`124`	`{`
`123`	`125`	`if (changeEvent.newValue.HasValue)`
`124`	`126`	`{`
`@@ -130,18 +132,18 @@ private void OnSelectionChange(ChangeEvent<GlobalId?> changeEvent)`
`130`	`132`	`}`
`131`	`133`	`}`
`132`	`134`
`133`		`- private string OnSelectionNameFormat(GlobalId? id)`
	`135`	`+ private string OnSelectionNameFormat(int? id)`
`134`	`136`	`{`
`135`		`- return id.HasValue ? Menus[id.Value].name : "None";`
	`137`	`+ return id.HasValue ? Menus[id.Value].Name : NoneMenuName;`
`136`	`138`	`}`
`137`	`139`
`138`		`- private List<GlobalId?> OnSelectionCreateList()`
	`140`	`+ private List<int?> OnSelectionCreateList()`
`139`	`141`	`{`
`140`		`- var list = new List<GlobalId?> { default };`
	`142`	`+ var list = new List<int?> { default };`
`141`	`143`
`142`		`- foreach ((GlobalId id, _) in Menus)`
	`144`	`+ for (int i = 0; i < Menus.Count; i++)`
`143`	`145`	`{`
`144`		`- list.Add(id);`
	`146`	`+ list.Add(i);`
`145`	`147`	`}`
`146`	`148`
`147`	`149`	`return list;`