fix: Fixed NullReferenceException when choosing a type for a generic unity object

Removed event usage in SelectedNode setter and moved it to the HandleKeyboardEvents method

Author: SolidAlloy

Editor/TypeDropdown/SelectionTree.KeyboardInput.cs

@@ -8,103 +8,94 @@ internal partial class SelectionTree
     {
         #region KeyboardEvents
 
-        protected void HandleKeyboardEvents()
+        private void HandleKeyboardEvents()
         {
-            // KeyDown is always used somehow, so we use KeyUp here
             if (Event.current.type != EventType.KeyDown)
                 return;
 
-            switch (Event.current.keyCode)
+            bool eventUsed = Event.current.keyCode switch
             {
-                case KeyCode.RightArrow:
-                    OnArrowRight();
-                    break;
-                case KeyCode.LeftArrow:
-                    OnArrowLeft();
-                    break;
-                case KeyCode.KeypadEnter:
-                case KeyCode.Return:
-                    OnEnter();
-                    break;
-                case KeyCode.DownArrow:
-                    if (_noneElement is { IsSelected: true })
-                    {
-                        OnArrowDownNone();
-                    }
-                    else
-                    {
-                        OnArrowDown();
-                    }
-                    break;
-                case KeyCode.UpArrow:
-                    OnArrowUp();
-                    break;
-            }
+                KeyCode.RightArrow => OnArrowRight(),
+                KeyCode.LeftArrow => OnArrowLeft(),
+                KeyCode.KeypadEnter => OnEnter(),
+                KeyCode.Return => OnEnter(),
+                KeyCode.DownArrow => _noneElement is { IsSelected: true } ? OnArrowDownNone() : OnArrowDown(),
+                KeyCode.UpArrow => OnArrowUp(),
+                _ => false
+            };
+
+            if (eventUsed)
+                Event.current.Use();
         }
 
-        private void OnArrowRight()
+        private bool OnArrowRight()
         {
             if (!SelectedNode.IsFolder || SelectedNode.Expanded)
-                return;
+                return false;
 
             SelectedNode.Expanded = true;
-            Event.current.Use();
+            return true;
         }
 
-        private void OnArrowLeft()
+        private bool OnArrowLeft()
         {
             if (!SelectedNode.IsFolder || !SelectedNode.Expanded)
-                return;
+                return false;
 
             SelectedNode.Expanded = false;
-            Event.current.Use();
+            return true;
         }
 
-        private void OnEnter()
+        private bool OnEnter()
         {
             if (SelectedNode.IsFolder)
             {
                 SelectedNode.Expanded = ! SelectedNode.Expanded;
-                RequestRepaint();
             }
             else
             {
                 FinalizeSelection();
             }
+
+            return true;
         }
 
-        private void OnArrowDown()
+        private bool OnArrowDown()
         {
             if (SelectedNode.IsFolder && SelectedNode.Expanded)
             {
                 SelectedNode = SelectedNode.ChildNodes[0];
+                return true;
             }
-            else
-            {
-                if (SelectedNode.IsRoot)
-                    return;
 
-                SelectedNode = SelectedNode.ParentNode.GetNextChild(SelectedNode);
+            if (SelectedNode.IsRoot)
+                return false;
 
-                if (!_visibleRect.Contains(SelectedNode.Rect))
-                {
-                    _scrollbar.RequestScrollToNode(SelectedNode, Scrollbar.NodePosition.Bottom);
-                }
+            SelectedNode = SelectedNode.ParentNode.GetNextChild(SelectedNode);
+
+            if (!_visibleRect.Contains(SelectedNode.Rect))
+            {
+                _scrollbar.RequestScrollToNode(SelectedNode, Scrollbar.NodePosition.Bottom);
             }
+
+            return true;
         }
 
-        private void OnArrowDownNone()
+        private bool OnArrowDownNone()
         {
             var firstItem = _root.ChildNodes.FirstOrDefault();
 
-            if (firstItem != null)
-                SelectedNode = firstItem;
+            if (firstItem == null)
+                return false;
+
+            SelectedNode = firstItem;
+            return true;
         }
 
-        private void OnArrowUp()
+        private bool OnArrowUp()
         {
             if (SelectedNode.IsRoot)
-                return;
+                return false;
 
             if (SelectedNode.ParentNode.IsRoot)
             {
@@ -113,7 +104,7 @@ private void OnArrowUp()
                 if (isFirst && _noneElement != null)
                 {
                     SelectedNode = _noneElement;
-                    return;
+                    return true;
                 }
             }
 
@@ -131,6 +122,8 @@ private void OnArrowUp()
             {
                 _scrollbar.RequestScrollToNode(SelectedNode, Scrollbar.NodePosition.Top);
             }
+
+            return true;
         }
 
         private bool IsExpandedFolder(SelectionNode previousNode)

Editor/TypeDropdown/SelectionTree.cs

@@ -26,9 +26,9 @@ internal partial class SelectionTree : IRepainter
         private readonly Scrollbar _scrollbar;
 
         private string _searchString = string.Empty;
-        private SelectionNode _selectedNode;
         private Rect _visibleRect;
         public bool RepaintRequested;
+        public SelectionNode SelectedNode;
 
         public SelectionTree(
             TypeItem[] items,
@@ -55,18 +55,6 @@ public SelectionTree(
 
         public string[] SelectionPaths { get; }
 
-        public SelectionNode SelectedNode
-        {
-            get => _selectedNode;
-            set
-            {
-                _selectedNode = value;
-
-                if (Event.current.type != EventType.Layout)
-                    Event.current.Use();
-            }
-        }
-
         public bool DrawInSearchMode { get; private set; }
 
         private List<SelectionNode> Nodes => _root.ChildNodes;