XY focus

samples/ControlCatalog/MainView.xaml

@@ -95,6 +95,9 @@
       <TabItem Header="Flyouts">
         <pages:FlyoutsPage />
       </TabItem>
+      <TabItem Header="Focus">
+        <pages:FocusPage />
+      </TabItem>
       <TabItem Header="Gestures">
         <pages:GesturePage />
       </TabItem>

samples/ControlCatalog/Pages/FocusPage.xaml

@@ -0,0 +1,50 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:generic="clr-namespace:System.Collections.Generic;assembly=netstandard"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="ControlCatalog.Pages.FocusPage">
+  <TabControl>
+    <TabItem Header="XY Focus">
+      <StackPanel x:Name="TabRoot" XYFocus.KeyboardNavigationEnabled="{Binding #KeyboardNavigation.SelectedItem}">
+        <StackPanel Orientation="Horizontal" Spacing="10">
+          <TextBlock Text="Navigation: " />
+          <ComboBox x:Name="KeyboardNavigation" SelectedIndex="0">
+            <ComboBox.ItemsSource>
+              <generic:List x:TypeArguments="XYFocusKeyboardNavigationMode">
+                <XYFocusKeyboardNavigationMode>Enabled</XYFocusKeyboardNavigationMode>
+                <XYFocusKeyboardNavigationMode>Disabled</XYFocusKeyboardNavigationMode>
+              </generic:List>
+            </ComboBox.ItemsSource>
+          </ComboBox>
+          <ComboBox x:Name="NavigationStrategy" SelectedIndex="0">
+            <ComboBox.ItemsSource>
+              <generic:List x:TypeArguments="XYFocusNavigationStrategy">
+                <XYFocusNavigationStrategy>Projection</XYFocusNavigationStrategy>
+                <XYFocusNavigationStrategy>NavigationDirectionDistance</XYFocusNavigationStrategy>
+                <XYFocusNavigationStrategy>RectilinearDistance</XYFocusNavigationStrategy>
+              </generic:List>
+            </ComboBox.ItemsSource>
+          </ComboBox>
+        </StackPanel>
+
+        <Canvas HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Width="500">
+          <Canvas.Styles>
+            <Style Selector="Button">
+              <Setter Property="XYFocus.UpNavigationStrategy" Value="{Binding #NavigationStrategy.SelectedItem}" />
+              <Setter Property="XYFocus.DownNavigationStrategy" Value="{Binding #NavigationStrategy.SelectedItem}" />
+              <Setter Property="XYFocus.LeftNavigationStrategy" Value="{Binding #NavigationStrategy.SelectedItem}" />
+              <Setter Property="XYFocus.RightNavigationStrategy" Value="{Binding #NavigationStrategy.SelectedItem}" />
+            </Style>
+          </Canvas.Styles>
+
+          <Button Canvas.Top="0" Canvas.Left="50" Width="150" Height="150">A</Button>
+          <Button Canvas.Top="150" Canvas.Left="400" Width="50" Height="50">C</Button>
+          <Button Canvas.Top="200" Canvas.Left="0" Width="50" Height="50">B</Button>
+          <Button Canvas.Top="300" Canvas.Left="100" Width="50" Height="50">D</Button>
+        </Canvas>
+      </StackPanel>
+    </TabItem>
+  </TabControl>
+</UserControl>

samples/ControlCatalog/Pages/FocusPage.xaml.cs

@@ -0,0 +1,14 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace ControlCatalog.Pages;
+
+public partial class FocusPage : UserControl
+{
+    public FocusPage()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+}
+

src/Avalonia.Base/Controls/IInternalScroller.cs

@@ -0,0 +1,10 @@
+using System.Runtime.CompilerServices;
+
+namespace Avalonia.Controls.Primitives;
+
+internal interface IInternalScroller
+{
+    bool CanHorizontallyScroll { get; }
+
+    bool CanVerticallyScroll { get; }
+}

src/Avalonia.Base/Input/FocusManager.cs

@@ -164,7 +164,7 @@ internal bool TryMoveFocus(NavigationDirection direction)
         /// </summary>
         /// <param name="e">The element.</param>
         /// <returns>True if the element can be focused.</returns>
-        private static bool CanFocus(IInputElement e) => e.Focusable && e.IsEffectivelyEnabled && IsVisible(e);
+        internal static bool CanFocus(IInputElement e) => e.Focusable && e.IsEffectivelyEnabled && IsVisible(e);
 
         /// <summary>
         /// Gets the focus scope of the specified control, traversing popups.

src/Avalonia.Base/Input/KeyboardNavigationHandler.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using Avalonia.Input.Navigation;
+using Avalonia.Input;
 using Avalonia.Metadata;
 using Avalonia.VisualTree;
 
@@ -16,7 +17,7 @@ public sealed class KeyboardNavigationHandler : IKeyboardNavigationHandler
         /// The window to which the handler belongs.
         /// </summary>
         private IInputRoot? _owner;
-
+        
         /// <summary>
         /// Sets the owner of the keyboard navigation handler.
         /// </summary>
@@ -60,6 +61,9 @@ public void SetOwner(IInputRoot owner)
             {
                 NavigationDirection.Next => TabNavigation.GetNextTab(element, false),
                 NavigationDirection.Previous => TabNavigation.GetPrevTab(element, null, false),
+                NavigationDirection.Up or NavigationDirection.Down
+                    or NavigationDirection.Left or NavigationDirection.Right
+                    => XYFocus.TryDirectionalFocus(direction, element, null),
                 _ => throw new NotSupportedException(),
             };
 
@@ -113,6 +117,20 @@ void OnKeyDown(object? sender, KeyEventArgs e)
                 Move(current, direction, e.KeyModifiers);
                 e.Handled = true;
             }
+            else if (e.Key is Key.Left or Key.Right or Key.Up or Key.Down)
+            {
+                var current = FocusManager.GetFocusManager(e.Source as IInputElement)?.GetFocusedElement();
+                var direction = e.Key switch
+                {
+                    Key.Left => NavigationDirection.Left,
+                    Key.Right => NavigationDirection.Right,
+                    Key.Up => NavigationDirection.Up,
+                    Key.Down => NavigationDirection.Down,
+                    _ => throw new ArgumentOutOfRangeException()
+                };
+                Move(current, direction, e.KeyModifiers);
+                e.Handled = true;
+            }
         }
 
         private static bool HandlePreCustomNavigation(

src/Avalonia.Base/Input/Navigation/XYFocus.Bubbling.cs

@@ -0,0 +1,165 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input.Navigation;
+using Avalonia.Media;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Input;
+
+public partial class XYFocus
+{
+    private static InputElement? GetDirectionOverride(
+        InputElement element,
+        InputElement? searchRoot,
+        NavigationDirection direction,
+        bool ignoreFocusabililty = false)
+    {
+        var index = GetXYFocusPropertyIndex(element, direction);
+
+        if (index != null)
+        {
+            var overrideElement = element.GetValue(index) as InputElement;
+
+            if (overrideElement != null)
+            {
+                if ((!ignoreFocusabililty && !FocusManager.CanFocus(overrideElement)))
+                    return null;
+
+                // If an override was specified but it is located outside the searchRoot, don't use it as the candidate.
+                if (searchRoot != null &&
+                    !searchRoot.IsVisualAncestorOf(overrideElement))
+                    return null;
+
+                return overrideElement;
+            }
+        }
+
+        return null;
+    }
+
+    private static InputElement? TryXYFocusBubble(
+        InputElement element,
+        InputElement? candidate,
+        InputElement? searchRoot,
+        NavigationDirection direction)
+    {
+        if (candidate == null)
+            return null;
+
+        var nextFocusableElement = candidate;
+        var directionOverrideRoot = GetDirectionOverrideRoot(element, searchRoot, direction);
+
+        if (directionOverrideRoot != null)
+        {
+            var isAncestor = directionOverrideRoot.IsVisualAncestorOf(candidate);
+            if (!isAncestor)
+            {
+                nextFocusableElement = GetDirectionOverride(directionOverrideRoot, searchRoot, direction)
+                                       ?? nextFocusableElement;
+            }
+        }
+
+        return nextFocusableElement;
+    }
+
+    private static InputElement? GetDirectionOverrideRoot(
+        InputElement element,
+        InputElement? searchRoot,
+        NavigationDirection direction)
+    {
+        var root = element;
+
+        while (root != null && GetDirectionOverride(root, searchRoot, direction) == null)
+        {
+            root = root.GetVisualParent() as InputElement;
+        }
+
+        return root;
+    }
+
+    private static XYFocusNavigationStrategy GetStrategy(
+        InputElement element,
+        NavigationDirection direction,
+        XYFocusNavigationStrategy? navigationStrategyOverride)
+    {
+        var isAutoOverride = navigationStrategyOverride == XYFocusNavigationStrategy.Auto;
+
+        if (navigationStrategyOverride.HasValue && !isAutoOverride)
+        {
+            // We can cast just by offsetting values because we have ensured that the XYFocusStrategy enums offset as expected
+            return (XYFocusNavigationStrategy)(int)(navigationStrategyOverride.Value - 1);
+        }
+        else if (isAutoOverride && element.GetVisualParent() is InputElement parent)
+        {
+            // Skip the element if we have an auto override and look at its parent's strategy
+            element = parent;
+        }
+
+        var index = GetXYFocusNavigationStrategyPropertyIndex(element, direction);
+        if (index is not null)
+        {
+            var current = element;
+            while (current != null && current.GetValue(index) is XYFocusNavigationStrategy mode)
+            {
+                if (mode != XYFocusNavigationStrategy.Auto)
+                {
+                    return mode;
+                }
+
+                current = current.GetVisualParent() as InputElement;
+            }
+        }
+
+        return XYFocusNavigationStrategy.Projection;
+    }
+
+    private static AvaloniaProperty? GetXYFocusPropertyIndex(
+        InputElement element,
+        NavigationDirection direction)
+    {
+        if (element.FlowDirection == FlowDirection.RightToLeft)
+        {
+            if (direction == NavigationDirection.Left) direction = NavigationDirection.Right;
+            else if (direction == NavigationDirection.Right) direction = NavigationDirection.Left;
+        }
+
+        switch (direction)
+        {
+            case NavigationDirection.Left:
+                return LeftProperty;
+            case NavigationDirection.Right:
+                return RightProperty;
+            case NavigationDirection.Up:
+                return UpProperty;
+            case NavigationDirection.Down:
+                return DownProperty;
+        }
+
+        return null;
+    }
+
+    private static AvaloniaProperty? GetXYFocusNavigationStrategyPropertyIndex(
+        InputElement element,
+        NavigationDirection direction)
+    {
+        if (element.FlowDirection == FlowDirection.RightToLeft)
+        {
+            if (direction == NavigationDirection.Left) direction = NavigationDirection.Right;
+            else if (direction == NavigationDirection.Right) direction = NavigationDirection.Left;
+        }
+
+        switch (direction)
+        {
+            case NavigationDirection.Left:
+                return LeftNavigationStrategyProperty;
+            case NavigationDirection.Right:
+                return RightNavigationStrategyProperty;
+            case NavigationDirection.Up:
+                return UpNavigationStrategyProperty;
+            case NavigationDirection.Down:
+                return DownNavigationStrategyProperty;
+        }
+
+        return null;
+    }
+}