Port tab navigation algorithm from WPF (including TabIndex support)

src/Avalonia.Controls/TopLevel.cs

@@ -90,6 +90,7 @@ public abstract class TopLevel : ContentControl,
         /// </summary>
         static TopLevel()
         {
+            KeyboardNavigation.TabNavigationProperty.OverrideDefaultValue<TopLevel>(KeyboardNavigationMode.Cycle);
             AffectsMeasure<TopLevel>(ClientSizeProperty);
 
             TransparencyLevelHintProperty.Changed.AddClassHandler<TopLevel>(

src/Avalonia.Input/Avalonia.Input.csproj

@@ -4,6 +4,9 @@
     <Nullable>Enable</Nullable>
     <WarningsAsErrors>CS8600;CS8602;CS8603</WarningsAsErrors>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="..\Avalonia.Base\Metadata\NullableAttributes.cs" Link="NullableAttributes.cs" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Avalonia.Animation\Avalonia.Animation.csproj" />
     <ProjectReference Include="..\Avalonia.Base\Avalonia.Base.csproj" />

src/Avalonia.Input/FocusManager.cs

@@ -92,6 +92,17 @@ static FocusManager()
             }
         }
 
+        public IInputElement? GetFocusedElement(IInputElement e)
+        {
+            if (e is IFocusScope scope)
+            {
+                _focusScopes.TryGetValue(scope, out var result);
+                return result;
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Sets the currently focused element in the specified scope.
         /// </summary>
@@ -151,6 +162,8 @@ public void SetFocusScope(IFocusScope scope)
             Focus(e);
         }
 
+        public static bool GetIsFocusScope(IInputElement e) => e is IFocusScope;
+
         /// <summary>
         /// Checks if the specified element can be focused.
         /// </summary>

src/Avalonia.Input/ICustomKeyboardNavigation.cs

@@ -1,11 +1,24 @@
-
+#nullable enable
+
 namespace Avalonia.Input
 {
     /// <summary>
     /// Designates a control as handling its own keyboard navigation.
     /// </summary>
     public interface ICustomKeyboardNavigation
     {
-        (bool handled, IInputElement next) GetNext(IInputElement element, NavigationDirection direction);
+        /// <summary>
+        /// Gets the next element in the specified navigation direction.
+        /// </summary>
+        /// <param name="element">The element being navigated from.</param>
+        /// <param name="direction">The navigation direction.</param>
+        /// <returns>
+        /// A tuple consisting of:
+        /// - A boolean indicating whether the request was handled. If false is returned then 
+        ///   custom navigation will be ignored and default navigation will take place.
+        /// - If handled is true: the next element in the navigation direction, or null if default
+        ///   navigation should continue outside the element.
+        /// </returns>
+        (bool handled, IInputElement? next) GetNext(IInputElement element, NavigationDirection direction);
     }
 }

src/Avalonia.Input/InputElement.cs

@@ -71,6 +71,12 @@ public class InputElement : Interactive, IInputElement
         public static readonly DirectProperty<InputElement, bool> IsPointerOverProperty =
             AvaloniaProperty.RegisterDirect<InputElement, bool>(nameof(IsPointerOver), o => o.IsPointerOver);
 
+        /// <summary>
+        /// Defines the <see cref="IsTabStop"/> property.
+        /// </summary>
+        public static readonly StyledProperty<bool> IsTabStopProperty =
+            KeyboardNavigation.IsTabStopProperty.AddOwner<InputElement>();
+
         /// <summary>
         /// Defines the <see cref="GotFocus"/> event.
         /// </summary>
@@ -99,6 +105,12 @@ public class InputElement : Interactive, IInputElement
                 "KeyUp",
                 RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
 
+        /// <summary>
+        /// Defines the <see cref="TabIndex"/> property.
+        /// </summary>
+        public static readonly StyledProperty<int> TabIndexProperty =
+            KeyboardNavigation.TabIndexProperty.AddOwner<InputElement>();
+
         /// <summary>
         /// Defines the <see cref="TextInput"/> event.
         /// </summary>
@@ -426,6 +438,15 @@ public bool IsPointerOver
             internal set { SetAndRaise(IsPointerOverProperty, ref _isPointerOver, value); }
         }
 
+        /// <summary>
+        /// Gets or sets a value that indicates whether the control is included in tab navigation.
+        /// </summary>
+        public bool IsTabStop
+        {
+            get => GetValue(IsTabStopProperty);
+            set => SetValue(IsTabStopProperty, value);
+        }
+
         /// <inheritdoc/>
         public bool IsEffectivelyEnabled
         {
@@ -437,6 +458,16 @@ private set
             }
         }
 
+        /// <summary>
+        /// Gets or sets a value that determines the order in which elements receive focus when the
+        /// user navigates through controls by pressing the Tab key.
+        /// </summary>
+        public int TabIndex
+        {
+            get => GetValue(TabIndexProperty);
+            set => SetValue(TabIndexProperty, value);
+        }
+
         public List<KeyBinding> KeyBindings { get; } = new List<KeyBinding>();
 
         /// <summary>

src/Avalonia.Input/KeyboardNavigation.cs

@@ -5,6 +5,15 @@ namespace Avalonia.Input
     /// </summary>
     public static class KeyboardNavigation
     {
+        /// <summary>
+        /// Defines the TabIndex attached property.
+        /// </summary>
+        public static readonly AttachedProperty<int> TabIndexProperty =
+            AvaloniaProperty.RegisterAttached<StyledElement, int>(
+                "TabIndex",
+                typeof(KeyboardNavigation),
+                int.MaxValue);
+
         /// <summary>
         /// Defines the TabNavigation attached property.
         /// </summary>
@@ -42,6 +51,26 @@ public static class KeyboardNavigation
                 typeof(KeyboardNavigation), 
                 true);
 
+        /// <summary>
+        /// Gets the <see cref="TabIndexProperty"/> for an element.
+        /// </summary>
+        /// <param name="element">The container.</param>
+        /// <returns>The <see cref="KeyboardNavigationMode"/> for the container.</returns>
+        public static int GetTabIndex(IInputElement element)
+        {
+            return ((IAvaloniaObject)element).GetValue(TabIndexProperty);
+        }
+
+        /// <summary>
+        /// Sets the <see cref="TabIndexProperty"/> for an element.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        /// <param name="value">The tab index.</param>
+        public static void SetTabIndex(IInputElement element, int value)
+        {
+            ((IAvaloniaObject)element).SetValue(TabIndexProperty, value);
+        }
+
         /// <summary>
         /// Gets the <see cref="TabNavigationProperty"/> for a container.
         /// </summary>
@@ -83,7 +112,7 @@ public static void SetTabOnceActiveElement(InputElement element, IInputElement?
         }
 
         /// <summary>
-        /// Sets the <see cref="IsTabStopProperty"/> for a container.
+        /// Sets the <see cref="IsTabStopProperty"/> for an element.
         /// </summary>
         /// <param name="element">The container.</param>
         /// <param name="value">Value indicating whether the container is a tab stop.</param>
@@ -93,7 +122,7 @@ public static void SetIsTabStop(InputElement element, bool value)
         }
 
         /// <summary>
-        /// Gets the <see cref="IsTabStopProperty"/> for a container.
+        /// Gets the <see cref="IsTabStopProperty"/> for an element.
         /// </summary>
         /// <param name="element">The container.</param>
         /// <returns>Whether the container is a tab stop.</returns>

src/Avalonia.Input/KeyboardNavigationHandler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Avalonia.Input.Navigation;
 using Avalonia.VisualTree;
@@ -48,39 +49,24 @@ public void SetOwner(IInputRoot owner)
         {
             element = element ?? throw new ArgumentNullException(nameof(element));
 
-            var customHandler = element.GetSelfAndVisualAncestors()
-                .OfType<ICustomKeyboardNavigation>()
-                .FirstOrDefault();
+            // If there's a custom keyboard navigation handler as an ancestor, use that.
+            var custom = element.FindAncestorOfType<ICustomKeyboardNavigation>(true);
+            if (custom is object && HandlePreCustomNavigation(custom, element, direction, out var ce))
+                return ce;
 
-            if (customHandler != null)
+            var result = direction switch
             {
-                var (handled, next) = customHandler.GetNext(element, direction);
+                NavigationDirection.Next => TabNavigation.GetNextTab(element, false),
+                NavigationDirection.Previous => TabNavigation.GetPrevTab(element, null, false),
+                _ => throw new NotSupportedException(),
+            };
 
-                if (handled)
-                {
-                    if (next != null)
-                    {
-                        return next;
-                    }
-                    else if (direction == NavigationDirection.Next || direction == NavigationDirection.Previous)
-                    {
-                        return TabNavigation.GetNextInTabOrder((IInputElement)customHandler, direction, true);
-                    }
-                    else
-                    {
-                        return null;
-                    }
-                }
-            }
+            // If there wasn't a custom navigation handler as an ancestor of the current element,
+            // but there is one as an ancestor of the new element, use that.
+            if (custom is null && HandlePostCustomNavigation(element, result, direction, out ce))
+                return ce;
 
-            if (direction == NavigationDirection.Next || direction == NavigationDirection.Previous)
-            {
-                return TabNavigation.GetNextInTabOrder(element, direction);
-            }
-            else
-            {
-                throw new NotSupportedException();
-            }
+            return result;
         }
 
         /// <summary>
@@ -90,7 +76,7 @@ public void SetOwner(IInputRoot owner)
         /// <param name="direction">The direction to move.</param>
         /// <param name="keyModifiers">Any key modifiers active at the time of focus.</param>
         public void Move(
-            IInputElement element, 
+            IInputElement element,
             NavigationDirection direction,
             KeyModifiers keyModifiers = KeyModifiers.None)
         {
@@ -124,5 +110,70 @@ protected virtual void OnKeyDown(object sender, KeyEventArgs e)
                 e.Handled = true;
             }
         }
+
+        private static bool HandlePreCustomNavigation(
+            ICustomKeyboardNavigation customHandler,
+            IInputElement element,
+            NavigationDirection direction,
+            [NotNullWhen(true)] out IInputElement? result)
+        {
+            if (customHandler != null)
+            {
+                var (handled, next) = customHandler.GetNext(element, direction);
+
+                if (handled)
+                {
+                    if (next != null)
+                    {
+                        result = next;
+                        return true;
+                    }
+                    else if (direction == NavigationDirection.Next || direction == NavigationDirection.Previous)
+                    {
+                        var r = direction switch
+                        {
+                            NavigationDirection.Next => TabNavigation.GetNextTabOutside(customHandler),
+                            NavigationDirection.Previous => TabNavigation.GetPrevTabOutside(customHandler),
+                            _ => throw new NotSupportedException(),
+                        };
+
+                        if (r is object)
+                        {
+                            result = r;
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            result = null;
+            return false;
+        }
+
+        private static bool HandlePostCustomNavigation(
+            IInputElement element,
+            IInputElement? newElement,
+            NavigationDirection direction,
+            [NotNullWhen(true)] out IInputElement? result)
+        {
+            if (newElement is object)
+            {
+                var customHandler = newElement.FindAncestorOfType<ICustomKeyboardNavigation>(true);
+
+                if (customHandler is object)
+                {
+                    var (handled, next) = customHandler.GetNext(element, direction);
+
+                    if (handled && next is object)
+                    {
+                        result = next;
+                        return true;
+                    }
+                }
+            }
+
+            result = null;
+            return false;
+        }
     }
 }

src/Avalonia.Input/KeyboardNavigationMode.cs

@@ -36,5 +36,10 @@ public enum KeyboardNavigationMode
         /// The container's children will not be focused when using the tab key.
         /// </summary>
         None,
+
+        /// <summary>
+        /// TabIndexes are considered on local subtree only inside this container
+        /// </summary>
+        Local,
     }
-}
+}