Merge branch 'master' into tabcontrol-disabled-bindable

osu.Framework.Tests/Containers/TestSceneContainerState.cs

···
             AddAssert("correct count", () => count == 2);
         }
 
+        [Test]
+        public void TestAliveChildrenContainsOnlyAliveChildren()
+        {
+            Container container = null;
+            Drawable aliveChild = null;
+            Drawable nonAliveChild = null;
+
+            AddStep("create container", () =>
+            {
+                Child = container = new Container
+                {
+                    Children = new[]
+                    {
+                        aliveChild = new Box(),
+                        nonAliveChild = new Box { LifetimeStart = double.MaxValue }
+                    }
+                };
+            });
+
+            AddAssert("1 alive child", () => container.AliveChildren.Count == 1);
+            AddAssert("alive child contained", () => container.AliveChildren.Contains(aliveChild));
+            AddAssert("non-alive child not contained", () => !container.AliveChildren.Contains(nonAliveChild));
+        }
+
         private class TestContainer : Container
         {
             public new void ScheduleAfterChildren(Action action) => SchedulerAfterChildren.AddDelayed(action, TransformDelay);

osu.Framework.Tests/Visual/UserInterface/TestSceneDropdown.cs

···
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Framework.Input.States;
 using osu.Framework.Testing;
 using osuTK;
 using osuTK.Input;
···
         private const int items_to_add = 10;
         private const float explicit_height = 100;
         private float calculatedHeight;
-        private readonly TestDropdown testDropdown, testDropdownMenu, bindableDropdown;
+        private readonly TestDropdown testDropdown, testDropdownMenu, bindableDropdown, emptyDropdown;
+        private readonly PlatformActionContainer platformActionContainerKeyboardSelection, platformActionContainerKeyboardPreselection, platformActionContainerEmptyDropdown;
         private readonly BindableList<string> bindableList = new BindableList<string>();
 
+        private int previousIndex;
+        private int lastVisibleIndexOnTheCurrentPage, lastVisibleIndexOnTheNextPage;
+        private int firstVisibleIndexOnTheCurrentPage, firstVisibleIndexOnThePreviousPage;
+
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(Dropdown<>),
···
             while (i < items_to_add)
                 testItems[i] = @"test " + i++;
 
-            Add(testDropdown = new TestDropdown
+            Add(platformActionContainerKeyboardSelection = new PlatformActionContainer
             {
-                Width = 150,
-                Position = new Vector2(200, 70),
-                Items = testItems
+                Child = testDropdown = new TestDropdown
+                {
+                    Width = 150,
+                    Position = new Vector2(200, 70),
+                    Items = testItems
+                }
             });
 
-            Add(testDropdownMenu = new TestDropdown
+            Add(platformActionContainerKeyboardPreselection = new PlatformActionContainer
             {
-                Width = 150,
-                Position = new Vector2(400, 70),
-                Items = testItems
+                Child = testDropdownMenu = new TestDropdown
+                {
+                    Width = 150,
+                    Position = new Vector2(400, 70),
+                    Items = testItems
+                }
             });
+            testDropdownMenu.Menu.MaxHeight = explicit_height;
 
             Add(bindableDropdown = new TestDropdown
             {
                 Width = 150,
                 Position = new Vector2(600, 70),
                 ItemSource = bindableList
+            });
+
+            Add(platformActionContainerEmptyDropdown = new PlatformActionContainer
+            {
+                Child = emptyDropdown = new TestDropdown
+                {
+                    Width = 150,
+                    Position = new Vector2(800, 70),
+                }
             });
         }
 
···
             AddAssert("current value should be two", () => bindableDropdown.Current.Value == "two");
         }
 
+        private void performKeypress(Drawable drawable, Key key)
+        {
+            drawable.TriggerEvent(new KeyDownEvent(new InputState(), key));
+            drawable.TriggerEvent(new KeyUpEvent(new InputState(), key));
+        }
+
+        private void performPlatformAction(PlatformAction action, PlatformActionContainer platformActionContainer, Drawable drawable)
+        {
+            var tempIsHovered = drawable.IsHovered;
+            var tempHasFocus = drawable.HasFocus;
+
+            drawable.IsHovered = true;
+            drawable.HasFocus = true;
+
+            platformActionContainer.TriggerPressed(action);
+            platformActionContainer.TriggerReleased(action);
+
+            drawable.IsHovered = tempIsHovered;
+            drawable.HasFocus = tempHasFocus;
+        }
+
+        [Test]
+        public void KeyboardSelection()
+        {
+            AddStep("Select next item", () =>
+            {
+                previousIndex = testDropdown.SelectedIndex;
+                performKeypress(testDropdown.Header, Key.Down);
+            });
+
+            AddAssert("Next item is selected", () => testDropdown.SelectedIndex == previousIndex + 1);
+
+            AddStep("Select previous item", () =>
+            {
+                previousIndex = testDropdown.SelectedIndex;
+                performKeypress(testDropdown.Header, Key.Up);
+            });
+
+            AddAssert("Previous item is selected", () => testDropdown.SelectedIndex == previousIndex - 1);
+
+            AddStep("Select last item",
+                () => performPlatformAction(new PlatformAction(PlatformActionType.ListEnd, PlatformActionMethod.Move), platformActionContainerKeyboardSelection, testDropdown.Header));
+
+            AddAssert("Last item selected", () => testDropdown.SelectedItem == testDropdown.Menu.DrawableMenuItems.Last().Item);
+
+            AddStep("Select first item",
+                () => performPlatformAction(new PlatformAction(PlatformActionType.ListStart, PlatformActionMethod.Move), platformActionContainerKeyboardSelection, testDropdown.Header));
+
+            AddAssert("First item selected", () => testDropdown.SelectedItem == testDropdown.Menu.DrawableMenuItems.First().Item);
+
+            AddStep("Select next item when empty", () => performKeypress(emptyDropdown.Header, Key.Up));
+
+            AddStep("Select previous item when empty", () => performKeypress(emptyDropdown.Header, Key.Down));
+
+            AddStep("Select last item when empty", () => performKeypress(emptyDropdown.Header, Key.PageUp));
+
+            AddStep("Select first item when empty", () => performKeypress(emptyDropdown.Header, Key.PageDown));
+        }
+
+        [Test]
+        public void KeyboardPreselection()
+        {
+            clickKeyboardPreselectionDropdown();
+            assertDropdownIsOpen();
+
+            AddStep("Preselect next item", () =>
+            {
+                previousIndex = testDropdownMenu.PreselectedIndex;
+                performKeypress(testDropdownMenu.Menu, Key.Down);
+            });
+
+            AddAssert("Next item is preselected", () => testDropdownMenu.PreselectedIndex == previousIndex + 1);
+
+            AddStep("Preselect previous item", () =>
+            {
+                previousIndex = testDropdownMenu.PreselectedIndex;
+                performKeypress(testDropdownMenu.Menu, Key.Up);
+            });
+
+            AddAssert("Previous item is preselected", () => testDropdownMenu.PreselectedIndex == previousIndex - 1);
+
+            AddStep("Preselect last visible item", () =>
+            {
+                lastVisibleIndexOnTheCurrentPage = testDropdownMenu.Menu.DrawableMenuItems.ToList().IndexOf(testDropdownMenu.Menu.VisibleMenuItems.Last());
+                performKeypress(testDropdownMenu.Menu, Key.PageDown);
+            });
+
+            AddAssert("Last visible item preselected", () => testDropdownMenu.PreselectedIndex == lastVisibleIndexOnTheCurrentPage);
+
+            AddStep("Preselect last visible item on the next page", () =>
+            {
+                lastVisibleIndexOnTheNextPage =
+                    MathHelper.Clamp(lastVisibleIndexOnTheCurrentPage + testDropdownMenu.Menu.VisibleMenuItems.Count(), 0, testDropdownMenu.Menu.Items.Count - 1);
+
+                performKeypress(testDropdownMenu.Menu, Key.PageDown);
+            });
+
+            AddAssert("Last visible item on the next page preselected", () => testDropdownMenu.PreselectedIndex == lastVisibleIndexOnTheNextPage);
+
+            AddStep("Preselect first visible item", () =>
+            {
+                firstVisibleIndexOnTheCurrentPage = testDropdownMenu.Menu.DrawableMenuItems.ToList().IndexOf(testDropdownMenu.Menu.VisibleMenuItems.First());
+                performKeypress(testDropdownMenu.Menu, Key.PageUp);
+            });
+
+            AddAssert("First visible item preselected", () => testDropdownMenu.PreselectedIndex == firstVisibleIndexOnTheCurrentPage);
+
+            AddStep("Preselect first visible item on the previous page", () =>
+            {
+                firstVisibleIndexOnThePreviousPage = MathHelper.Clamp(firstVisibleIndexOnTheCurrentPage - testDropdownMenu.Menu.VisibleMenuItems.Count(), 0,
+                    testDropdownMenu.Menu.Items.Count - 1);
+                performKeypress(testDropdownMenu.Menu, Key.PageUp);
+            });
+
+            AddAssert("First visible item on the previous page selected", () => testDropdownMenu.PreselectedIndex == firstVisibleIndexOnThePreviousPage);
+
+            AddAssert("First item is preselected", () => testDropdownMenu.Menu.PreselectedItem.Item == testDropdownMenu.Menu.DrawableMenuItems.First().Item);
+
+            AddStep("Preselect last item",
+                () => performPlatformAction(new PlatformAction(PlatformActionType.ListEnd, PlatformActionMethod.Move), platformActionContainerKeyboardPreselection, testDropdownMenu));
+
+            AddAssert("Last item preselected", () => testDropdownMenu.Menu.PreselectedItem.Item == testDropdownMenu.Menu.DrawableMenuItems.Last().Item);
+
+            AddStep("Finalize selection", () => { performKeypress(testDropdownMenu.Menu, Key.Enter); });
+
+            assertLastItemSelected();
+
+            assertDropdownIsClosed();
+
+            clickKeyboardPreselectionDropdown();
+
+            assertDropdownIsOpen();
+
+            AddStep("Preselect first item",
+                () => performPlatformAction(new PlatformAction(PlatformActionType.ListStart, PlatformActionMethod.Move), platformActionContainerKeyboardPreselection, testDropdownMenu));
+
+            AddAssert("First item preselected", () => testDropdownMenu.Menu.PreselectedItem.Item == testDropdownMenu.Menu.DrawableMenuItems.First().Item);
+
+            AddStep("Discard preselection", () => performKeypress(testDropdownMenu.Menu, Key.Escape));
+
+            assertDropdownIsClosed();
+
+            assertLastItemSelected();
+
+            AddStep($"Click {emptyDropdown}", () => toggleDropdownViaClick(emptyDropdown));
+
+            AddStep("Preselect next item when empty", () =>
+            {
+                performKeypress(emptyDropdown.Menu, Key.Down);
+            });
+
+            AddStep("Preselect previous item when empty", () =>
+            {
+                performKeypress(emptyDropdown.Menu, Key.Up);
+            });
+
+            AddStep("Preselect first visible item when empty", () =>
+            {
+                performKeypress(emptyDropdown.Menu, Key.PageUp);
+            });
+
+            AddStep("Preselect last visible item when empty", () =>
+            {
+                performKeypress(emptyDropdown.Menu, Key.PageDown);
+            });
+
+            AddStep("Preselect first item when empty",
+                () => performPlatformAction(new PlatformAction(PlatformActionType.ListStart, PlatformActionMethod.Move), platformActionContainerEmptyDropdown, emptyDropdown));
+
+            AddStep("Preselect last item when empty",
+                () => performPlatformAction(new PlatformAction(PlatformActionType.ListEnd, PlatformActionMethod.Move), platformActionContainerEmptyDropdown, emptyDropdown));
+
+            void clickKeyboardPreselectionDropdown() => AddStep("click keyboardPreselectionDropdown", () => toggleDropdownViaClick(testDropdownMenu));
+
+            void assertDropdownIsOpen() => AddAssert("dropdown is open", () => testDropdownMenu.Menu.State == MenuState.Open);
+
+            void assertLastItemSelected() => AddAssert("Last item selected", () => testDropdownMenu.SelectedItem == testDropdownMenu.Menu.DrawableMenuItems.Last().Item);
+
+            void assertDropdownIsClosed() => AddAssert("dropdown is closed", () => testDropdownMenu.Menu.State == MenuState.Closed);
+        }
+
         [Test]
         public void SelectNull()
         {
···
                 public void SelectItem(MenuItem item) => Children.FirstOrDefault(c => c.Item == item)?
                     .TriggerEvent(new ClickEvent(GetContainingInputManager().CurrentState, MouseButton.Left));
             }
+
+            internal new DropdownMenuItem<string> SelectedItem => base.SelectedItem;
+
+            public int SelectedIndex => Menu.DrawableMenuItems.Select(d => d.Item).ToList().IndexOf(SelectedItem);
+            public int PreselectedIndex => Menu.DrawableMenuItems.ToList().IndexOf(Menu.PreselectedItem);
         }
     }
 }

osu.Framework/Graphics/Containers/Container.cs

···
                 internalChildrenAsT = (IReadOnlyList<T>)InternalChildren;
             else
                 internalChildrenAsT = new LazyList<Drawable, T>(InternalChildren, c => (T)c);
+
+            if (typeof(T) == typeof(Drawable))
+                aliveInternalChildrenAsT = (IReadOnlyList<T>)AliveInternalChildren;
+            else
+                aliveInternalChildrenAsT = new LazyList<Drawable, T>(AliveInternalChildren, c => (T)c);
         }
 
         /// <summary>
···
                 return internalChildrenAsT;
             }
             set => ChildrenEnumerable = value;
+        }
+
+        /// <summary>
+        /// The publicly accessible list of alive children. Forwards to the alive children of <see cref="Content"/>.
+        /// If <see cref="Content"/> is this container, then returns <see cref="CompositeDrawable.AliveInternalChildren"/>.
+        /// </summary>
+        public IReadOnlyList<T> AliveChildren
+        {
+            get
+            {
+                if (Content != this)
+                    return Content.AliveChildren;
+
+                return aliveInternalChildrenAsT;
+            }
         }
 
         /// <summary>
···
         }
 
         private readonly IReadOnlyList<T> internalChildrenAsT;
+        private readonly IReadOnlyList<T> aliveInternalChildrenAsT;
 
         /// <summary>
         /// The index of a given child within <see cref="Children"/>.

osu.Framework/Graphics/UserInterface/Dropdown.cs

···
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osuTK;
 using osuTK.Graphics;
-using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics.Sprites;
+using osuTK.Input;
 
 namespace osu.Framework.Graphics.UserInterface
 {
···
             Menu.RelativeSizeAxes = Axes.X;
 
             Header.Action = Menu.Toggle;
+            Header.ChangeSelection += selectionKeyPressed;
+            Menu.PreselectionConfirmed += preselectionConfirmed;
             Current.ValueChanged += selectionChanged;
 
             ItemSource.ItemsAdded += _ => setItems(ItemSource);
             ItemSource.ItemsRemoved += _ => setItems(ItemSource);
+        }
+
+        private void preselectionConfirmed(int selectedIndex)
+        {
+            SelectedItem = MenuItems.ElementAt(selectedIndex);
+            Menu.State = MenuState.Closed;
+        }
+
+        private void selectionKeyPressed(DropdownHeader.DropdownSelectionAction action)
+        {
+            if (!MenuItems.Any())
+                return;
+
+            var dropdownMenuItems = MenuItems.ToList();
+
+            switch (action)
+            {
+                case DropdownHeader.DropdownSelectionAction.Previous:
+                    SelectedItem = dropdownMenuItems[MathHelper.Clamp(dropdownMenuItems.IndexOf(SelectedItem) - 1, 0, dropdownMenuItems.Count - 1)];
+                    break;
+
+                case DropdownHeader.DropdownSelectionAction.Next:
+                    SelectedItem = dropdownMenuItems[MathHelper.Clamp(dropdownMenuItems.IndexOf(SelectedItem) + 1, 0, dropdownMenuItems.Count - 1)];
+                    break;
+
+                case DropdownHeader.DropdownSelectionAction.First:
+                    SelectedItem = dropdownMenuItems[0];
+                    break;
+
+                case DropdownHeader.DropdownSelectionAction.Last:
+                    SelectedItem = dropdownMenuItems[^1];
+                    break;
+
+                default:
+                    throw new ArgumentException("Unexpected selection action type.", nameof(action));
+            }
         }
 
         protected override void LoadComplete()
···
 
         #region DropdownMenu
 
-        public abstract class DropdownMenu : Menu
+        public abstract class DropdownMenu : Menu, IKeyBindingHandler<PlatformAction>
         {
             protected DropdownMenu()
                 : base(Direction.Vertical)
             {
+                StateChanged += clearPreselection;
             }
 
+            public override void Add(MenuItem item)
+            {
+                base.Add(item);
+
+                var drawableDropdownMenuItem = (DrawableDropdownMenuItem)ItemsContainer.Single(drawableItem => drawableItem.Item == item);
+                drawableDropdownMenuItem.PreselectionRequested += PreselectItem;
+            }
+
+            private void clearPreselection(MenuState obj)
+            {
+                if (obj == MenuState.Closed)
+                    PreselectItem(null);
+            }
+
+            protected internal IEnumerable<DrawableDropdownMenuItem> DrawableMenuItems => Children.OfType<DrawableDropdownMenuItem>();
+            protected internal IEnumerable<DrawableDropdownMenuItem> VisibleMenuItems => DrawableMenuItems.Where(item => !item.IsMaskedAway);
+
+            public DrawableDropdownMenuItem PreselectedItem => Children.OfType<DrawableDropdownMenuItem>().FirstOrDefault(c => c.IsPreSelected)
+                                                               ?? Children.OfType<DrawableDropdownMenuItem>().FirstOrDefault(c => c.IsSelected);
+
+            public event Action<int> PreselectionConfirmed;
+
             /// <summary>
             /// Selects an item from this <see cref="DropdownMenu"/>.
             /// </summary>
             /// <param name="item">The item to select.</param>
             public void SelectItem(DropdownMenuItem<T> item)
             {
-                Children.OfType<DrawableDropdownMenuItem>().ForEach(c => c.IsSelected = c.Item == item);
+                Children.OfType<DrawableDropdownMenuItem>().ForEach(c =>
+                {
+                    c.IsSelected = c.Item == item;
+                    if (c.IsSelected)
+                        ContentContainer.ScrollIntoView(c);
+                });
             }
 
             /// <summary>
···
             /// </summary>
             public bool AnyPresent => Children.Any(c => c.IsPresent);
 
+            protected void PreselectItem(int index) => PreselectItem(Items[MathHelper.Clamp(index, 0, DrawableMenuItems.Count() - 1)]);
+
+            /// <summary>
+            /// Preselects an item from this <see cref="DropdownMenu"/>.
+            /// </summary>
+            /// <param name="item">The item to select.</param>
+            protected void PreselectItem(MenuItem item)
+            {
+                Children.OfType<DrawableDropdownMenuItem>().ForEach(c =>
+                {
+                    c.IsPreSelected = c.Item == item;
+                    if (c.IsPreSelected)
+                        ContentContainer.ScrollIntoView(c);
+                });
+            }
+
             protected sealed override DrawableMenuItem CreateDrawableMenuItem(MenuItem item) => CreateDrawableDropdownMenuItem(item);
 
             protected abstract DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item);
···
             // must be public due to mono bug(?) https://github.com/ppy/osu/issues/1204
             public abstract class DrawableDropdownMenuItem : DrawableMenuItem
             {
+                public event Action<DropdownMenuItem<T>> PreselectionRequested;
+
                 protected DrawableDropdownMenuItem(MenuItem item)
                     : base(item)
                 {
···
                     }
                 }
 
+                private bool preSelected;
+
+                /// <summary>
+                /// Denotes whether this menu item will be selected on <see cref="Key.Enter"/> press.
+                /// This property is related to selecting menu items using keyboard or hovering.
+                /// </summary>
+                public bool IsPreSelected
+                {
+                    get => preSelected;
+                    set
+                    {
+                        if (preSelected == value)
+                            return;
+
+                        preSelected = value;
+
+                        OnSelectChange();
+                    }
+                }
+
                 private Color4 backgroundColourSelected = Color4.SlateGray;
 
                 public Color4 BackgroundColourSelected
···
 
                 protected override void UpdateBackgroundColour()
                 {
-                    Background.FadeColour(IsHovered ? BackgroundColourHover : IsSelected ? BackgroundColourSelected : BackgroundColour);
+                    Background.FadeColour(IsPreSelected ? BackgroundColourHover : IsSelected ? BackgroundColourSelected : BackgroundColour);
                 }
 
                 protected override void UpdateForegroundColour()
                 {
-                    Foreground.FadeColour(IsHovered ? ForegroundColourHover : IsSelected ? ForegroundColourSelected : ForegroundColour);
+                    Foreground.FadeColour(IsPreSelected ? ForegroundColourHover : IsSelected ? ForegroundColourSelected : ForegroundColour);
                 }
 
                 protected override void LoadComplete()
···
                     Background.Colour = IsSelected ? BackgroundColourSelected : BackgroundColour;
                     Foreground.Colour = IsSelected ? ForegroundColourSelected : ForegroundColour;
                 }
+
+                protected override bool OnHover(HoverEvent e)
+                {
+                    PreselectionRequested?.Invoke(Item as DropdownMenuItem<T>);
+                    return base.OnHover(e);
+                }
             }
 
             #endregion
+
+            protected override bool OnKeyDown(KeyDownEvent e)
+            {
+                var drawableMenuItemsList = DrawableMenuItems.ToList();
+                if (!drawableMenuItemsList.Any())
+                    return base.OnKeyDown(e);
+
+                var currentPreselected = drawableMenuItemsList.FirstOrDefault(i => i.IsPreSelected) ?? drawableMenuItemsList.First(i => i.IsSelected);
+
+                var targetPreselectionIndex = drawableMenuItemsList.IndexOf(currentPreselected);
+
+                switch (e.Key)
+                {
+                    case Key.Up:
+                        PreselectItem(targetPreselectionIndex - 1);
+                        return true;
+
+                    case Key.Down:
+                        PreselectItem(targetPreselectionIndex + 1);
+                        return true;
+
+                    case Key.PageUp:
+                        var firstVisibleItem = VisibleMenuItems.First();
+
+                        if (currentPreselected == firstVisibleItem)
+                            PreselectItem(targetPreselectionIndex - VisibleMenuItems.Count());
+                        else
+                            PreselectItem(drawableMenuItemsList.IndexOf(firstVisibleItem));
+                        return true;
+
+                    case Key.PageDown:
+                        var lastVisibleItem = VisibleMenuItems.Last();
+
+                        if (currentPreselected == lastVisibleItem)
+                            PreselectItem(targetPreselectionIndex + VisibleMenuItems.Count());
+                        else
+                            PreselectItem(drawableMenuItemsList.IndexOf(lastVisibleItem));
+                        return true;
+
+                    case Key.Enter:
+                        PreselectionConfirmed?.Invoke(targetPreselectionIndex);
+                        return true;
+
+                    case Key.Escape:
+                        State = MenuState.Closed;
+                        return true;
+
+                    default:
+                        return base.OnKeyDown(e);
+                }
+            }
+
+            public bool OnPressed(PlatformAction action)
+            {
+                switch (action.ActionType)
+                {
+                    case PlatformActionType.ListStart:
+                        PreselectItem(Items.FirstOrDefault());
+                        return true;
+
+                    case PlatformActionType.ListEnd:
+                        PreselectItem(Items.LastOrDefault());
+                        return true;
+
+                    default:
+                        return false;
+                }
+            }
+
+            public bool OnReleased(PlatformAction action) => false;
         }
 
         #endregion

osu.Framework/Graphics/UserInterface/DropdownHeader.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using osuTK.Graphics;
+using System;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osuTK.Input;
 
 namespace osu.Framework.Graphics.UserInterface
 {
-    public abstract class DropdownHeader : ClickableContainer
+    public abstract class DropdownHeader : ClickableContainer, IKeyBindingHandler<PlatformAction>
     {
+        public event Action<DropdownSelectionAction> ChangeSelection;
+
         protected Container Background;
         protected Container Foreground;
 
···
         {
             Background.Colour = BackgroundColour;
             base.OnHoverLost(e);
+        }
+
+        public override bool HandleNonPositionalInput => IsHovered;
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            switch (e.Key)
+            {
+                case Key.Up:
+                    ChangeSelection?.Invoke(DropdownSelectionAction.Previous);
+                    return true;
+
+                case Key.Down:
+                    ChangeSelection?.Invoke(DropdownSelectionAction.Next);
+                    return true;
+
+                default:
+                    return base.OnKeyDown(e);
+            }
+        }
+
+        public bool OnPressed(PlatformAction action)
+        {
+            switch (action.ActionType)
+            {
+                case PlatformActionType.ListStart:
+                    ChangeSelection?.Invoke(DropdownSelectionAction.First);
+                    return true;
+
+                case PlatformActionType.ListEnd:
+                    ChangeSelection?.Invoke(DropdownSelectionAction.Last);
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        public bool OnReleased(PlatformAction action) => false;
+
+        public enum DropdownSelectionAction
+        {
+            Previous,
+            Next,
+            First,
+            Last,
+            FirstVisible,
+            LastVisible
         }
     }
 }

osu.Framework/Graphics/UserInterface/Menu.cs

···
         /// <summary>
         /// Gets the item representations contained by this <see cref="Menu"/>.
         /// </summary>
-        protected IReadOnlyList<DrawableMenuItem> Children => ItemsContainer;
+        protected internal IReadOnlyList<DrawableMenuItem> Children => ItemsContainer;
 
         protected readonly Direction Direction;
 

osu.Framework/Input/PlatformActionContainer.cs

···
         LineEnd,
         DocumentPrevious,
         DocumentNext,
+        ListStart,
+        ListEnd,
         Save
     }
 

osu.Framework/Platform/GameHost.cs

···
             new KeyBinding(new KeyCombination(InputKey.Control, InputKey.PageDown), new PlatformAction(PlatformActionType.DocumentNext)),
             new KeyBinding(new KeyCombination(InputKey.Control, InputKey.Tab), new PlatformAction(PlatformActionType.DocumentNext)),
             new KeyBinding(new KeyCombination(InputKey.Control, InputKey.Shift, InputKey.Tab), new PlatformAction(PlatformActionType.DocumentPrevious)),
-            new KeyBinding(new KeyCombination(InputKey.Control, InputKey.S), new PlatformAction(PlatformActionType.Save))
+            new KeyBinding(new KeyCombination(InputKey.Control, InputKey.S), new PlatformAction(PlatformActionType.Save)),
+            new KeyBinding(InputKey.Home, new PlatformAction(PlatformActionType.ListStart, PlatformActionMethod.Move)),
+            new KeyBinding(InputKey.End, new PlatformAction(PlatformActionType.ListEnd, PlatformActionMethod.Move))
         };
 
         /// <summary>

osu.Framework/Platform/MacOS/MacOSGameHost.cs

···
             new KeyBinding(new KeyCombination(InputKey.Alt, InputKey.Super, InputKey.Right), new PlatformAction(PlatformActionType.DocumentNext)),
             new KeyBinding(new KeyCombination(InputKey.Control, InputKey.Tab), new PlatformAction(PlatformActionType.DocumentNext)),
             new KeyBinding(new KeyCombination(InputKey.Control, InputKey.Shift, InputKey.Tab), new PlatformAction(PlatformActionType.DocumentPrevious)),
-            new KeyBinding(new KeyCombination(InputKey.Super, InputKey.S), new PlatformAction(PlatformActionType.Save))
+            new KeyBinding(new KeyCombination(InputKey.Super, InputKey.S), new PlatformAction(PlatformActionType.Save)),
+            new KeyBinding(new KeyCombination(InputKey.Super, InputKey.Up), new PlatformAction(PlatformActionType.ListStart, PlatformActionMethod.Move)),
+            new KeyBinding(new KeyCombination(InputKey.Super, InputKey.Down), new PlatformAction(PlatformActionType.ListEnd, PlatformActionMethod.Move))
         };
     }
 }