feat: Added ability to move through the list of types using keyboard

Author: SolidAlloy

Editor/TypeDropdown/DropdownWindow.cs

@@ -183,8 +183,11 @@ private void DrawContent()
 
         private void RepaintIfMouseWasUsed()
         {
-            if (Event.current.isMouse || Event.current.type == EventType.Used)
+            if (Event.current.isMouse || Event.current.type == EventType.Used || _selectionTree.RepaintRequested)
+            {
                 Repaint();
+                _selectionTree.RepaintRequested = false;
+            }
         }
 
         private readonly struct FixedRect : IDisposable

Editor/TypeDropdown/IRepainter.cs

@@ -0,0 +1,7 @@
+namespace TypeReferences.Editor.TypeDropdown
+{
+    public interface IRepainter
+    {
+        void RequestRepaint();
+    }
+}

Editor/TypeDropdown/IRepainter.cs.meta

@@ -1,5 +1,6 @@
 namespace TypeReferences.Editor.TypeDropdown
 {
+    using System.Linq;
     using UnityEditor;
     using UnityEngine;
 

Editor/TypeDropdown/NoneElement.cs

@@ -9,14 +9,23 @@
     /// </summary>
     internal class Scrollbar
     {
+        private readonly IRepainter _repainter;
+
         private bool _visible = true;
         private Vector2 _position;
-        private SelectionNode _nodeToScrollTo;
         private Rect _wholeListRect;
         private Rect _windowRect;
 
+        private SelectionNode _nodeToScrollTo;
+        private NodePosition _nodePosition;
+
         private static bool ScrollCannotBePerformed => Event.current.type != EventType.Repaint;
 
+        public Scrollbar(IRepainter repainter)
+        {
+            _repainter = repainter;
+        }
+
         /// <summary>Draws elements with scrollbar if the list is large enough.</summary>
         /// <returns>
         /// A scrollbar scope that automatically lays out elements inside the list and places a thumb in the correct position.
@@ -28,20 +37,21 @@ internal class Scrollbar
 
         /// <summary>Ask scrollbar to start moving to a node. The process can take several frames.</summary>
         /// <param name="node">The node to scroll to.</param>
-        public void RequestScrollToNode(SelectionNode node)
+        public void RequestScrollToNode(SelectionNode node, NodePosition nodePosition)
         {
             if (node == null)
                 return;
 
             _nodeToScrollTo = node;
+            _nodePosition = nodePosition;
 
             foreach (SelectionNode parentNode in node.GetParentNodesRecursive(false))
                 parentNode.Expanded = true;
 
             if (ScrollCannotBePerformed)
                 return;
 
-            ScrollToNode(node.Rect);
+            ScrollToNode(node.Rect, nodePosition);
             _nodeToScrollTo = null;
         }
 
@@ -50,14 +60,27 @@ private void ScrollToNodeIfNeeded()
             if (_nodeToScrollTo == null || ScrollCannotBePerformed)
                 return;
 
-            ScrollToNode(_nodeToScrollTo.Rect);
+            ScrollToNode(_nodeToScrollTo.Rect, _nodePosition);
             _nodeToScrollTo = null;
         }
 
-        private void ScrollToNode(Rect nodeRect)
+        private void ScrollToNode(Rect nodeRect, NodePosition nodePosition)
         {
             float windowHalfHeight = _windowRect.height * 0.5f; // This is needed to center the item vertically.
-            _position.y = nodeRect.y - windowHalfHeight; // This scrolls to the node but places it in the center of the window.
+
+            // scroll to the node but also calculate where it needs to be inside the visible part of the dropdown.
+            float shift = nodePosition switch
+            {
+                NodePosition.Top => 0f,
+                NodePosition.Center => - windowHalfHeight,
+                NodePosition.Bottom => - windowHalfHeight * 2 + DropdownStyle.NodeHeight,
+                _ => throw new NotImplementedException()
+            };
+
+            var position = nodeRect.y + shift;
+            _position.y = position > 0 ? position : 0;
+
+            _repainter.RequestRepaint();
         }
 
         /// <summary>Draws elements with scrollbar if the list is large enough.</summary>
@@ -98,5 +121,7 @@ public void Dispose()
                 _scrollbar.ScrollToNodeIfNeeded();
             }
         }
+
+        public enum NodePosition { Top, Center, Bottom }
     }
 }

Editor/TypeDropdown/Scrollbar.cs

@@ -19,8 +19,8 @@ internal class SelectionNode
         public readonly Type Type;
 
         private readonly string _name;
-        private readonly SelectionTree _parentTree;
-        private readonly SelectionNode _parentNode;
+        protected readonly SelectionTree _parentTree;
+        public readonly SelectionNode ParentNode;
 
         private bool _expanded;
         private Rect _rect;
@@ -45,7 +45,7 @@ protected SelectionNode(
             Assert.IsNotNull(name);
 
             _name = name;
-            _parentNode = parentNode;
+            ParentNode = parentNode;
             _parentTree = parentTree;
             Type = type;
             FullTypeName = fullTypeName;
@@ -55,7 +55,7 @@ protected SelectionNode(
         /// <param name="parentTree">The tree this node belongs to.</param>
         private SelectionNode(SelectionTree parentTree)
         {
-            _parentNode = null;
+            ParentNode = null;
             _parentTree = parentTree;
             _name = string.Empty;
             Type = null;
@@ -76,15 +76,13 @@ public bool Expanded
             set => _expanded = value;
         }
 
-        private bool IsSelected => _parentTree.SelectedNode == this;
+        public bool IsFolder => ChildNodes.Count != 0;
 
-        private bool IsFolder => ChildNodes.Count != 0;
+        public bool IsRoot => ParentNode == null;
 
-        private bool IsHoveredOver => _rect.Contains(Event.current.mousePosition);
-
-        private bool IsRoot => _parentNode == null;
+        public bool IsSelected => _parentTree.SelectedNode == this;
 
-        public void Select() => _parentTree.SelectedNode = this;
+        private bool IsHoveredOver => _rect.Contains(Event.current.mousePosition);
 
         /// <summary>Creates a root node that does not have a parent and does not show up in the popup.</summary>
         /// <param name="parentTree">The tree this node belongs to.</param>
@@ -133,7 +131,7 @@ public IEnumerable<SelectionNode> GetParentNodesRecursive(
             if (IsRoot)
                 yield break;
 
-            foreach (SelectionNode node in _parentNode.GetParentNodesRecursive(true))
+            foreach (SelectionNode node in ParentNode.GetParentNodesRecursive(true))
                 yield return node;
         }
 
@@ -219,13 +217,44 @@ protected void HandleMouseEvents()
                 return;
 
             if (IsFolder)
+            {
                 Expanded = !Expanded;
+            }
             else
-                Select();
+            {
+                _parentTree.SelectedNode = this;
+                _parentTree.FinalizeSelection();
+            }
 
             Event.current.Use();
         }
 
+        public SelectionNode GetNextChild(SelectionNode currentChild)
+        {
+            int currentIndex = ChildNodes.IndexOf(currentChild);
+
+            if (currentIndex < 0)
+                return currentChild;
+
+            if (currentIndex == ChildNodes.Count - 1)
+                return ParentNode?.GetNextChild(this) ?? currentChild;
+
+            return ChildNodes[currentIndex + 1];
+        }
+
+        public SelectionNode GetPreviousChild(SelectionNode currentChild)
+        {
+            int currentIndex = ChildNodes.IndexOf(currentChild);
+
+            if (currentIndex < 0)
+                return currentChild;
+
+            if (currentIndex == 0)
+                return this;
+
+            return ChildNodes[currentIndex - 1];
+        }
+
         private void Draw(int indentLevel, Rect visibleRect)
         {
             if (ReserveSpaceAndStop())

Editor/TypeDropdown/SelectionNode.cs

@@ -0,0 +1,143 @@
+namespace TypeReferences.Editor.TypeDropdown
+{
+    using System.Linq;
+    using SolidUtilities.Editor.Extensions;
+    using UnityEngine;
+
+    internal partial class SelectionTree
+    {
+        #region KeyboardEvents
+
+        protected void HandleKeyboardEvents()
+        {
+            // KeyDown is always used somehow, so we use KeyUp here
+            if (Event.current.type != EventType.KeyDown)
+                return;
+
+            switch (Event.current.keyCode)
+            {
+                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;
+            }
+        }
+
+        private void OnArrowRight()
+        {
+            if (!SelectedNode.IsFolder || SelectedNode.Expanded)
+                return;
+
+            SelectedNode.Expanded = true;
+            Event.current.Use();
+        }
+
+        private void OnArrowLeft()
+        {
+            if (!SelectedNode.IsFolder || !SelectedNode.Expanded)
+                return;
+
+            SelectedNode.Expanded = false;
+            Event.current.Use();
+        }
+
+        private void OnEnter()
+        {
+            if (SelectedNode.IsFolder)
+            {
+                SelectedNode.Expanded = ! SelectedNode.Expanded;
+                RequestRepaint();
+            }
+            else
+            {
+                FinalizeSelection();
+            }
+        }
+
+        private void OnArrowDown()
+        {
+            if (SelectedNode.IsFolder && SelectedNode.Expanded)
+            {
+                SelectedNode = SelectedNode.ChildNodes[0];
+            }
+            else
+            {
+                if (SelectedNode.IsRoot)
+                    return;
+
+                SelectedNode = SelectedNode.ParentNode.GetNextChild(SelectedNode);
+
+                if (!_visibleRect.Contains(SelectedNode.Rect))
+                {
+                    _scrollbar.RequestScrollToNode(SelectedNode, Scrollbar.NodePosition.Bottom);
+                }
+            }
+        }
+
+        private void OnArrowDownNone()
+        {
+            var firstItem = _root.ChildNodes.FirstOrDefault();
+
+            if (firstItem != null)
+                SelectedNode = firstItem;
+        }
+
+        private void OnArrowUp()
+        {
+            if (SelectedNode.IsRoot)
+                return;
+
+            if (SelectedNode.ParentNode.IsRoot)
+            {
+                bool isFirst = SelectedNode.ParentNode.ChildNodes.IndexOf(SelectedNode) == 0;
+
+                if (isFirst && _noneElement != null)
+                {
+                    SelectedNode = _noneElement;
+                    return;
+                }
+            }
+
+            var previousNode = SelectedNode.ParentNode.GetPreviousChild(SelectedNode);
+
+            if (IsExpandedFolder(previousNode))
+            {
+                // choose last item of the previous folder instead.
+                previousNode = previousNode.ChildNodes[previousNode.ChildNodes.Count - 1];
+            }
+
+            SelectedNode = previousNode;
+
+            if (!_visibleRect.Contains(SelectedNode.Rect))
+            {
+                _scrollbar.RequestScrollToNode(SelectedNode, Scrollbar.NodePosition.Top);
+            }
+        }
+
+        private bool IsExpandedFolder(SelectionNode previousNode)
+        {
+            return SelectedNode.IsFolder && previousNode.IsFolder && previousNode.Expanded && previousNode.ChildNodes.Count != 0;
+        }
+
+        #endregion
+    }
+}