WIP

UnitTests/View/Navigation/AddRemoveTests.cs

@@ -0,0 +1,140 @@
+using Xunit.Abstractions;
+
+namespace Terminal.Gui.ViewTests;
+
+public class AddRemoveNavigationTests (ITestOutputHelper _output) : TestsAllViews
+{
+  [Fact]
+    public void Add_Subview_Gets_Focus ()
+    {
+        View top = new View ()
+        {
+            Id = "top",
+            CanFocus = true
+        };
+
+        top.SetFocus ();
+        Assert.True (top.HasFocus);
+
+        int nEnter = 0;
+        View subView = new View ()
+        {
+            Id = "subView",
+            CanFocus = true
+        };
+        subView.Enter += (s, e) => nEnter++;
+
+        top.Add (subView);
+
+        Assert.True (top.HasFocus);
+        Assert.Equal (subView, top.GetFocused ());
+        Assert.True (subView.HasFocus);
+        Assert.Equal (1, nEnter);
+    }
+
+    [Fact]
+    public void Add_Subview_Deepest_Gets_Focus ()
+    {
+        View top = new View ()
+        {
+            Id = "top",
+            CanFocus = true
+        };
+
+        top.SetFocus ();
+        Assert.True (top.HasFocus);
+
+        View subView = new View ()
+        {
+            Id = "subView",
+            CanFocus = true
+        };
+
+        View subSubView = new View ()
+        {
+            Id = "subSubView",
+            CanFocus = true
+        };
+
+        subView.Add (subSubView);
+
+        top.Add (subView);
+
+        Assert.True (top.HasFocus);
+        Assert.Equal (subView, top.GetFocused ());
+        Assert.True (subView.HasFocus);
+        Assert.True (subSubView.HasFocus);
+    }
+
+    [Fact]
+    public void Remove_Focused_Subview_Keeps_Focus_And_SubView_Looses_Focus ()
+    {
+        View top = new View ()
+        {
+            Id = "top",
+            CanFocus = true
+        };
+
+        int nLeave = 0;
+
+        View subView = new View ()
+        {
+            Id = "subView",
+            CanFocus = true
+        };
+        subView.Leave += (s, e) => nLeave++;
+
+        top.Add (subView);
+
+        top.SetFocus ();
+        Assert.True (top.HasFocus);
+        Assert.Equal (subView, top.GetFocused ());
+        Assert.True (subView.HasFocus);
+
+        top.Remove (subView);
+        Assert.True (top.HasFocus);
+        Assert.Equal (null, top.GetFocused ());
+        Assert.False (subView.HasFocus);
+        Assert.Equal (1, nLeave);
+    }
+
+    [Fact]
+    public void Remove_Focused_Subview_Keeps_Focus_And_SubView_Looses_Focus_And_Next_Gets_Focus ()
+    {
+        View top = new View ()
+        {
+            Id = "top",
+            CanFocus = true
+        };
+
+        int nLeave1 = 0;
+
+        View subView1 = new View ()
+        {
+            Id = "subView1",
+            CanFocus = true
+        };
+        subView1.Leave += (s, e) => nLeave1++;
+
+        View subView2 = new View ()
+        {
+            Id = "subView2",
+            CanFocus = true
+        };
+        top.Add (subView1, subView2);
+
+        top.SetFocus ();
+        Assert.True (top.HasFocus);
+        Assert.Equal (subView1, top.GetFocused ());
+        Assert.True (subView1.HasFocus);
+        Assert.False (subView2.HasFocus);
+
+        top.Remove (subView1);
+        Assert.True (top.HasFocus);
+        Assert.True (subView2.HasFocus);
+        Assert.Equal (subView2, top.GetFocused ());
+        Assert.False (subView1.HasFocus);
+        Assert.Equal (1, nLeave1);
+    }
+
+}

UnitTests/View/Navigation/AdvanceFocusTests.cs

@@ -0,0 +1,393 @@
+using Xunit.Abstractions;
+
+namespace Terminal.Gui.ViewTests;
+
+public class AdvanceFocusTests (ITestOutputHelper _output)
+{
+    [Fact]
+    public void Subviews_TabIndexes_AreEqual ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true };
+        var v2 = new View { CanFocus = true };
+        var v3 = new View { CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.Subviews.IndexOf (v2) == 1);
+        Assert.True (r.Subviews.IndexOf (v3) == 2);
+
+        Assert.True (r.TabIndexes.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v2) == 1);
+        Assert.True (r.TabIndexes.IndexOf (v3) == 2);
+
+        Assert.Equal (r.Subviews.IndexOf (v1), r.TabIndexes.IndexOf (v1));
+        Assert.Equal (r.Subviews.IndexOf (v2), r.TabIndexes.IndexOf (v2));
+        Assert.Equal (r.Subviews.IndexOf (v3), r.TabIndexes.IndexOf (v3));
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void TabIndex_Invert_Order ()
+    {
+        var r = new View ();
+        var v1 = new View { Id = "1", CanFocus = true };
+        var v2 = new View { Id = "2", CanFocus = true };
+        var v3 = new View { Id = "3", CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        v1.TabIndex = 2;
+        v2.TabIndex = 1;
+        v3.TabIndex = 0;
+        Assert.True (r.TabIndexes.IndexOf (v1) == 2);
+        Assert.True (r.TabIndexes.IndexOf (v2) == 1);
+        Assert.True (r.TabIndexes.IndexOf (v3) == 0);
+
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.Subviews.IndexOf (v2) == 1);
+        Assert.True (r.Subviews.IndexOf (v3) == 2);
+    }
+
+    [Fact]
+    public void TabIndex_Invert_Order_Added_One_By_One_Does_Not_Do_What_Is_Expected ()
+    {
+        var r = new View ();
+        var v1 = new View { Id = "1", CanFocus = true };
+        r.Add (v1);
+        v1.TabIndex = 2;
+        var v2 = new View { Id = "2", CanFocus = true };
+        r.Add (v2);
+        v2.TabIndex = 1;
+        var v3 = new View { Id = "3", CanFocus = true };
+        r.Add (v3);
+        v3.TabIndex = 0;
+
+        Assert.False (r.TabIndexes.IndexOf (v1) == 2);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 1);
+        Assert.False (r.TabIndexes.IndexOf (v2) == 1);
+        Assert.True (r.TabIndexes.IndexOf (v2) == 2);
+
+        // Only the last is in the expected index
+        Assert.True (r.TabIndexes.IndexOf (v3) == 0);
+
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.Subviews.IndexOf (v2) == 1);
+        Assert.True (r.Subviews.IndexOf (v3) == 2);
+    }
+
+    [Fact]
+    public void TabIndex_Invert_Order_Mixed ()
+    {
+        var r = new View ();
+        var vl1 = new View { Id = "vl1" };
+        var v1 = new View { Id = "v1", CanFocus = true };
+        var vl2 = new View { Id = "vl2" };
+        var v2 = new View { Id = "v2", CanFocus = true };
+        var vl3 = new View { Id = "vl3" };
+        var v3 = new View { Id = "v3", CanFocus = true };
+
+        r.Add (vl1, v1, vl2, v2, vl3, v3);
+
+        v1.TabIndex = 2;
+        v2.TabIndex = 1;
+        v3.TabIndex = 0;
+        Assert.True (r.TabIndexes.IndexOf (v1) == 4);
+        Assert.True (r.TabIndexes.IndexOf (v2) == 2);
+        Assert.True (r.TabIndexes.IndexOf (v3) == 0);
+
+        Assert.True (r.Subviews.IndexOf (v1) == 1);
+        Assert.True (r.Subviews.IndexOf (v2) == 3);
+        Assert.True (r.Subviews.IndexOf (v3) == 5);
+    }
+
+    [Fact]
+    public void TabIndex_Set_CanFocus_False ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true };
+        var v2 = new View { CanFocus = true };
+        var v3 = new View { CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        v1.CanFocus = false;
+        v1.TabIndex = 0;
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 0);
+        Assert.NotEqual (-1, v1.TabIndex);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void TabIndex_Set_CanFocus_False_To_True ()
+    {
+        var r = new View ();
+        var v1 = new View ();
+        var v2 = new View { CanFocus = true };
+        var v3 = new View { CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        v1.CanFocus = true;
+        v1.TabIndex = 1;
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 1);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void TabIndex_Set_CanFocus_HigherValues ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true };
+        var v2 = new View { CanFocus = true };
+        var v3 = new View { CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        v1.TabIndex = 3;
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 2);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void TabIndex_Set_CanFocus_LowerValues ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true };
+        var v2 = new View { CanFocus = true };
+        var v3 = new View { CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        //v1.TabIndex = -1;
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 0);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void TabIndex_Set_CanFocus_ValidValues ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true };
+        var v2 = new View { CanFocus = true };
+        var v3 = new View { CanFocus = true };
+
+        r.Add (v1, v2, v3);
+
+        v1.TabIndex = 1;
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 1);
+
+        v1.TabIndex = 2;
+        Assert.True (r.Subviews.IndexOf (v1) == 0);
+        Assert.True (r.TabIndexes.IndexOf (v1) == 2);
+        r.Dispose ();
+    }
+
+
+    [Theory]
+    [CombinatorialData]
+    public void TabStop_And_CanFocus_Are_Decoupled (bool canFocus, TabBehavior tabStop)
+    {
+        var view = new View { CanFocus = canFocus, TabStop = tabStop };
+
+        Assert.Equal (canFocus, view.CanFocus);
+        Assert.Equal (tabStop, view.TabStop);
+    }
+
+    [Fact]
+    public void AdvanceFocus_With_CanFocus_Are_All_True ()
+    {
+        var top = new View () { Id = "top", CanFocus = true };
+        var v1 = new View { Id = "v1", CanFocus = true };
+        var v2 = new View { Id = "v2", CanFocus = true };
+        var v3 = new View { Id = "v3", CanFocus = true };
+
+        top.Add (v1, v2, v3);
+
+        top.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.True (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        top.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.True (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        top.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.True (v3.HasFocus);
+        top.Dispose ();
+    }
+
+    [Fact]
+    public void AdvanceFocus_CanFocus_Mixed ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v2 = new View { CanFocus = false, TabStop = TabBehavior.TabStop };
+        var v3 = new View { CanFocus = false, TabStop = TabBehavior.NoStop };
+
+        r.Add (v1, v2, v3);
+
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.Dispose ();
+    }
+
+    [Theory]
+    [CombinatorialData]
+    public void AdvanceFocus_Change_CanFocus_Works ([CombinatorialValues (TabBehavior.NoStop, TabBehavior.TabStop, TabBehavior.TabGroup)] TabBehavior behavior)
+    {
+        var r = new View () { CanFocus = true };
+        var v1 = new View ();
+        var v2 = new View ();
+        var v3 = new View ();
+        Assert.True (r.CanFocus);
+        Assert.False (v1.CanFocus);
+        Assert.False (v2.CanFocus);
+        Assert.False (v3.CanFocus);
+
+        r.Add (v1, v2, v3);
+
+        r.AdvanceFocus (NavigationDirection.Forward, behavior);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+
+        v1.CanFocus = true;
+        v1.TabStop = behavior;
+        r.AdvanceFocus (NavigationDirection.Forward, behavior);
+        Assert.True (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+
+        v2.CanFocus = true;
+        v2.TabStop = behavior;
+        r.AdvanceFocus (NavigationDirection.Forward, behavior);
+        Assert.False (v1.HasFocus);
+        Assert.True (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+
+        v3.CanFocus = true;
+        v3.TabStop = behavior;
+        r.AdvanceFocus (NavigationDirection.Forward, behavior);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.True (v3.HasFocus);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void AdvanceFocus_NoStop_And_CanFocus_True_No_Focus ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v2 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v3 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+
+        r.Add (v1, v2, v3);
+
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void AdvanceFocus_NoStop_Change_Enables_Stop ()
+    {
+        var r = new View { CanFocus = true };
+        var v1 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v2 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v3 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+
+        r.Add (v1, v2, v3);
+
+        v1.TabStop = TabBehavior.TabStop;
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.True (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+
+        v2.TabStop = TabBehavior.TabStop;
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.True (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+
+        v3.TabStop = TabBehavior.TabStop;
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.True (v3.HasFocus);
+        r.Dispose ();
+    }
+
+    [Fact]
+    public void AdvacneFocus_NoStop_Prevents_Stop ()
+    {
+        var r = new View ();
+        var v1 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v2 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+        var v3 = new View { CanFocus = true, TabStop = TabBehavior.NoStop };
+
+        r.Add (v1, v2, v3);
+
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+    }
+
+    [Fact]
+    public void AdvanceFocus_Null_And_CanFocus_False_No_Advance ()
+    {
+        var r = new View ();
+        var v1 = new View ();
+        var v2 = new View ();
+        var v3 = new View ();
+        Assert.False (v1.CanFocus);
+        Assert.Null (v1.TabStop);
+
+        r.Add (v1, v2, v3);
+
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+        Assert.False (v1.HasFocus);
+        Assert.False (v2.HasFocus);
+        Assert.False (v3.HasFocus);
+        r.Dispose ();
+    }
+}

UnitTests/View/Navigation/CanFocusTests.cs

@@ -0,0 +1,580 @@
+using Xunit.Abstractions;
+
+namespace Terminal.Gui.ViewTests;
+
+public class CanFocusTests (ITestOutputHelper _output) : TestsAllViews
+{
+    [Fact]
+    public void CanFocus_False_Prevents_SubSubView_HasFocus ()
+    {
+        var view = new View { };
+        var subView = new View { };
+        var subSubView = new View { CanFocus = true };
+
+        subView.Add (subSubView);
+        view.Add (subView);
+
+        Assert.False (view.CanFocus);
+        Assert.False (subView.CanFocus);
+        Assert.True (subSubView.CanFocus);
+
+        view.SetFocus ();
+        Assert.False (view.HasFocus);
+
+        subView.SetFocus ();
+        Assert.False (subView.HasFocus);
+
+        subSubView.SetFocus ();
+        Assert.False (subSubView.HasFocus);
+    }
+
+    [Fact]
+    public void CanFocus_False_Prevents_SubView_HasFocus ()
+    {
+        var view = new View { };
+        var subView = new View { CanFocus = true };
+        var subSubView = new View { };
+
+        subView.Add (subSubView);
+        view.Add (subView);
+
+        Assert.False (view.CanFocus);
+        Assert.True (subView.CanFocus);
+        Assert.False (subSubView.CanFocus);
+
+        view.SetFocus ();
+        Assert.False (view.HasFocus);
+
+        subView.SetFocus ();
+        Assert.False (subView.HasFocus);
+
+        subSubView.SetFocus ();
+        Assert.False (subSubView.HasFocus);
+    }
+
+    [Fact]
+    public void CanFocus_Set_True_No_SuperView_Doesnt_Set_HasFocus ()
+    {
+        var view = new View { };
+
+        // Act
+        view.CanFocus = true;
+        Assert.False (view.HasFocus);
+    }
+
+    [Fact]
+    public void CanFocus_Set_True_Sets_HasFocus_To_True ()
+    {
+        var view = new View { };
+        var subView = new View { };
+        view.Add (subView);
+
+        Assert.False (view.CanFocus);
+        Assert.False (subView.CanFocus);
+
+        view.SetFocus ();
+        Assert.False (view.HasFocus);
+        Assert.False (subView.HasFocus);
+
+        view.CanFocus = true;
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+
+        // Act
+        subView.CanFocus = true;
+        Assert.True (subView.HasFocus);
+    }
+
+    [Fact]
+    public void CanFocus_Set_SubView_True_Sets_HasFocus_To_True ()
+    {
+        var view = new View
+        {
+            CanFocus = true
+        };
+        var subView = new View
+        {
+            CanFocus = false
+        };
+        var subSubView = new View
+        {
+            CanFocus = true
+        };
+
+        subView.Add (subSubView);
+        view.Add (subView);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.False (subView.HasFocus);
+        Assert.False (subSubView.HasFocus);
+
+        // Act
+        subView.CanFocus = true;
+        Assert.True (subView.HasFocus);
+        Assert.True (subSubView.HasFocus);
+    }
+
+
+    [Fact]
+    public void CanFocus_Set_SubView_True_Does_Not_Change_Focus_If_SuperView_Focused_Is_True ()
+    {
+        var top = new View
+        {
+            Id = "top",
+            CanFocus = true
+        };
+        var subView = new View
+        {
+            Id = "subView",
+            CanFocus = true
+        };
+        var subSubView = new View
+        {
+            Id = "subSubView",
+            CanFocus = true
+        };
+
+        subView.Add (subSubView);
+
+        var subView2 = new View
+        {
+            Id = "subView2",
+            CanFocus = false
+        };
+
+        top.Add (subView, subView2);
+
+        top.SetFocus ();
+        Assert.True (top.HasFocus);
+        Assert.Equal (subView, top.GetFocused ());
+        Assert.True (subView.HasFocus);
+        Assert.True (subSubView.HasFocus);
+
+        // Act
+        subView2.CanFocus = true;
+        Assert.False (subView2.HasFocus);
+        Assert.True (subView.HasFocus);
+        Assert.True (subSubView.HasFocus);
+    }
+
+    [Fact]
+    public void CanFocus_Set_False_Sets_HasFocus_To_False ()
+    {
+        var view = new View { CanFocus = true };
+        var view2 = new View { CanFocus = true };
+        view2.Add (view);
+
+        Assert.True (view.CanFocus);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+
+        view.CanFocus = false;
+        Assert.False (view.CanFocus);
+        Assert.False (view.HasFocus);
+    }
+
+    // TODO: Figure out what this test is supposed to be testing
+    [Fact]
+    public void CanFocus_Faced_With_Container ()
+    {
+        var t = new Toplevel ();
+        var w = new Window ();
+        var f = new FrameView ();
+        var v = new View { CanFocus = true };
+        f.Add (v);
+        w.Add (f);
+        t.Add (w);
+
+        Assert.True (t.CanFocus);
+        Assert.True (w.CanFocus);
+        Assert.True (f.CanFocus);
+        Assert.True (v.CanFocus);
+
+        f.CanFocus = false;
+        Assert.False (f.CanFocus);
+        Assert.True (v.CanFocus);
+
+        v.CanFocus = false;
+        Assert.False (f.CanFocus);
+        Assert.False (v.CanFocus);
+
+        v.CanFocus = true;
+        Assert.False (f.CanFocus);
+        Assert.True (v.CanFocus);
+    }
+
+    // TODO: Figure out what this test is supposed to be testing
+    [Fact]
+    public void CanFocus_Faced_With_Container_Before_Run ()
+    {
+        Application.Init (new FakeDriver ());
+
+        Toplevel t = new ();
+
+        var w = new Window ();
+        var f = new FrameView ();
+        var v = new View { CanFocus = true };
+        f.Add (v);
+        w.Add (f);
+        t.Add (w);
+
+        Assert.True (t.CanFocus);
+        Assert.True (w.CanFocus);
+        Assert.True (f.CanFocus);
+        Assert.True (v.CanFocus);
+
+        f.CanFocus = false;
+        Assert.False (f.CanFocus);
+        Assert.True (v.CanFocus);
+
+        v.CanFocus = false;
+        Assert.False (f.CanFocus);
+        Assert.False (v.CanFocus);
+
+        v.CanFocus = true;
+        Assert.False (f.CanFocus);
+        Assert.True (v.CanFocus);
+
+        Application.Iteration += (s, a) => Application.RequestStop ();
+
+        Application.Run (t);
+        t.Dispose ();
+        Application.Shutdown ();
+    }
+
+    [Fact]
+    public void CanFocus_Set_Changes_TabIndex_And_TabStop ()
+    {
+        var r = new View ();
+        var v1 = new View { Text = "1" };
+        var v2 = new View { Text = "2" };
+        var v3 = new View { Text = "3" };
+
+        r.Add (v1, v2, v3);
+
+        v2.CanFocus = true;
+        Assert.Equal (r.TabIndexes.IndexOf (v2), v2.TabIndex);
+        Assert.Equal (0, v2.TabIndex);
+        Assert.Equal (TabBehavior.TabStop, v2.TabStop);
+
+        v1.CanFocus = true;
+        Assert.Equal (r.TabIndexes.IndexOf (v1), v1.TabIndex);
+        Assert.Equal (1, v1.TabIndex);
+        Assert.Equal (TabBehavior.TabStop, v1.TabStop);
+
+        v1.TabIndex = 2;
+        Assert.Equal (r.TabIndexes.IndexOf (v1), v1.TabIndex);
+        Assert.Equal (1, v1.TabIndex);
+        v3.CanFocus = true;
+        Assert.Equal (r.TabIndexes.IndexOf (v1), v1.TabIndex);
+        Assert.Equal (1, v1.TabIndex);
+        Assert.Equal (r.TabIndexes.IndexOf (v3), v3.TabIndex);
+        Assert.Equal (2, v3.TabIndex);
+        Assert.Equal (TabBehavior.TabStop, v3.TabStop);
+
+        v2.CanFocus = false;
+        Assert.Equal (r.TabIndexes.IndexOf (v1), v1.TabIndex);
+        Assert.Equal (1, v1.TabIndex);
+        Assert.Equal (TabBehavior.TabStop, v1.TabStop);
+        Assert.Equal (r.TabIndexes.IndexOf (v2), v2.TabIndex); // TabIndex is not changed
+        Assert.NotEqual (-1, v2.TabIndex);
+        Assert.Equal (TabBehavior.TabStop, v2.TabStop); // TabStop is not changed
+        Assert.Equal (r.TabIndexes.IndexOf (v3), v3.TabIndex);
+        Assert.Equal (2, v3.TabIndex);
+        Assert.Equal (TabBehavior.TabStop, v3.TabStop);
+        r.Dispose ();
+    }
+
+
+
+#if V2_NEW_FOCUS_IMPL // Bogus test - depends on auto CanFocus behavior
+
+    [Fact]
+    public void CanFocus_Container_ToFalse_Turns_All_Subviews_ToFalse_Too ()
+    {
+        Application.Init (new FakeDriver ());
+
+        Toplevel t = new ();
+
+        var w = new Window ();
+        var f = new FrameView ();
+        var v1 = new View { CanFocus = true };
+        var v2 = new View { CanFocus = true };
+        f.Add (v1, v2);
+        w.Add (f);
+        t.Add (w);
+
+        t.Ready += (s, e) =>
+                   {
+                       Assert.True (t.CanFocus);
+                       Assert.True (w.CanFocus);
+                       Assert.True (f.CanFocus);
+                       Assert.True (v1.CanFocus);
+                       Assert.True (v2.CanFocus);
+
+                       w.CanFocus = false;
+                       Assert.False (w.CanFocus);
+                       Assert.False (f.CanFocus);
+                       Assert.False (v1.CanFocus);
+                       Assert.False (v2.CanFocus);
+                   };
+
+        Application.Iteration += (s, a) => Application.RequestStop ();
+
+        Application.Run (t);
+        t.Dispose ();
+        Application.Shutdown ();
+    }
+#endif
+
+#if V2_NEW_FOCUS_IMPL // Bogus test - depends on auto CanFocus behavior
+
+    [Fact]
+    public void CanFocus_Container_Toggling_All_Subviews_To_Old_Value_When_Is_True ()
+    {
+        Application.Init (new FakeDriver ());
+
+        Toplevel t = new ();
+
+        var w = new Window ();
+        var f = new FrameView ();
+        var v1 = new View ();
+        var v2 = new View { CanFocus = true };
+        f.Add (v1, v2);
+        w.Add (f);
+        t.Add (w);
+
+        t.Ready += (s, e) =>
+                   {
+                       Assert.True (t.CanFocus);
+                       Assert.True (w.CanFocus);
+                       Assert.True (f.CanFocus);
+                       Assert.False (v1.CanFocus);
+                       Assert.True (v2.CanFocus);
+
+                       w.CanFocus = false;
+                       Assert.False (w.CanFocus);
+                       Assert.False (f.CanFocus);
+                       Assert.False (v1.CanFocus);
+                       Assert.False (v2.CanFocus);
+
+                       w.CanFocus = true;
+                       Assert.True (w.CanFocus);
+                       Assert.True (f.CanFocus);
+                       Assert.False (v1.CanFocus);
+                       Assert.True (v2.CanFocus);
+                   };
+
+        Application.Iteration += (s, a) => Application.RequestStop ();
+
+        Application.Run (t);
+        t.Dispose ();
+        Application.Shutdown ();
+    }
+#endif
+#if V2_NEW_FOCUS_IMPL // Bogus test - depends on auto CanFocus behavior
+    [Fact]
+    public void CanFocus_Faced_With_Container_After_Run ()
+    {
+        Application.Init (new FakeDriver ());
+
+        Toplevel t = new ();
+
+        var w = new Window ();
+        var f = new FrameView ();
+        var v = new View { CanFocus = true };
+        f.Add (v);
+        w.Add (f);
+        t.Add (w);
+
+        t.Ready += (s, e) =>
+                   {
+                       Assert.True (t.CanFocus);
+                       Assert.True (w.CanFocus);
+                       Assert.True (f.CanFocus);
+                       Assert.True (v.CanFocus);
+
+                       f.CanFocus = false;
+                       Assert.False (f.CanFocus);
+                       Assert.False (v.CanFocus);
+
+                       v.CanFocus = false;
+                       Assert.False (f.CanFocus);
+                       Assert.False (v.CanFocus);
+
+                       Assert.Throws<InvalidOperationException> (() => v.CanFocus = true);
+                       Assert.False (f.CanFocus);
+                       Assert.False (v.CanFocus);
+
+                       f.CanFocus = true;
+                       Assert.True (f.CanFocus);
+                       Assert.True (v.CanFocus);
+                   };
+
+        Application.Iteration += (s, a) => Application.RequestStop ();
+
+        Application.Run (t);
+        t.Dispose ();
+        Application.Shutdown ();
+    }
+#endif
+#if V2_NEW_FOCUS_IMPL
+
+    [Fact]
+    [AutoInitShutdown]
+    public void CanFocus_Sets_To_False_On_Single_View_Focus_View_On_Another_Toplevel ()
+    {
+        var view1 = new View { Id = "view1", Width = 10, Height = 1, CanFocus = true };
+        var win1 = new Window { Id = "win1", Width = Dim.Percent (50), Height = Dim.Fill () };
+        win1.Add (view1);
+        var view2 = new View { Id = "view2", Width = 20, Height = 2, CanFocus = true };
+        var win2 = new Window { Id = "win2", X = Pos.Right (win1), Width = Dim.Fill (), Height = Dim.Fill () };
+        win2.Add (view2);
+        var top = new Toplevel ();
+        top.Add (win1, win2);
+        Application.Begin (top);
+
+        Assert.True (view1.CanFocus);
+        Assert.True (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
+
+        Assert.True (Application.OnKeyDown (Key.F6));
+        Assert.True (view1.CanFocus);
+        Assert.False (view1.HasFocus); // Only one of the most focused toplevels view can have focus
+        Assert.True (view2.CanFocus);
+        Assert.True (view2.HasFocus);
+
+        Assert.True (Application.OnKeyDown (Key.F6));
+        Assert.True (view1.CanFocus);
+        Assert.True (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
+
+        view1.CanFocus = false;
+        Assert.False (view1.CanFocus);
+        Assert.False (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.True (view2.HasFocus);
+        Assert.Equal (win2, Application.Current.GetFocused ());
+        Assert.Equal (view2, Application.Current.GetMostFocused ());
+        top.Dispose ();
+    }
+
+    [Fact]
+    [AutoInitShutdown]
+    public void CanFocus_Sets_To_False_On_Toplevel_Focus_View_On_Another_Toplevel ()
+    {
+        var view1 = new View { Id = "view1", Width = 10, Height = 1, CanFocus = true };
+        var win1 = new Window { Id = "win1", Width = Dim.Percent (50), Height = Dim.Fill () };
+        win1.Add (view1);
+        var view2 = new View { Id = "view2", Width = 20, Height = 2, CanFocus = true };
+        var win2 = new Window { Id = "win2", X = Pos.Right (win1), Width = Dim.Fill (), Height = Dim.Fill () };
+        win2.Add (view2);
+        var top = new Toplevel ();
+        top.Add (win1, win2);
+        Application.Begin (top);
+
+        Assert.True (view1.CanFocus);
+        Assert.True (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
+
+        Assert.True (Application.OnKeyDown (Key.F6));
+        Assert.True (view1.CanFocus);
+        Assert.False (view1.HasFocus); // Only one of the most focused toplevels view can have focus
+        Assert.True (view2.CanFocus);
+        Assert.True (view2.HasFocus);
+
+        Assert.True (Application.OnKeyDown (Key.F6));
+        Assert.True (view1.CanFocus);
+        Assert.True (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
+
+        win1.CanFocus = false;
+        Assert.False (view1.CanFocus);
+        Assert.False (view1.HasFocus);
+        Assert.False (win1.CanFocus);
+        Assert.False (win1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.True (view2.HasFocus);
+        Assert.Equal (win2, Application.Current.GetFocused ());
+        Assert.Equal (view2, Application.Current.GetMostFocused ());
+        top.Dispose ();
+    }
+
+    [Fact]
+    [AutoInitShutdown]
+    public void CanFocus_Sets_To_False_With_Two_Views_Focus_Another_View_On_The_Same_Toplevel ()
+    {
+        var view1 = new View { Id = "view1", Width = 10, Height = 1, CanFocus = true };
+
+        var view12 = new View
+        {
+            Id = "view12",
+            Y = 5,
+            Width = 10,
+            Height = 1,
+            CanFocus = true
+        };
+        var win1 = new Window { Id = "win1", Width = Dim.Percent (50), Height = Dim.Fill () };
+        win1.Add (view1, view12);
+        var view2 = new View { Id = "view2", Width = 20, Height = 2, CanFocus = true };
+        var win2 = new Window { Id = "win2", X = Pos.Right (win1), Width = Dim.Fill (), Height = Dim.Fill () };
+        win2.Add (view2);
+        var top = new Toplevel ();
+        top.Add (win1, win2);
+        Application.Begin (top);
+
+        Assert.True (view1.CanFocus);
+        Assert.True (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
+
+        Assert.True (Application.OnKeyDown (Key.F6)); // move to win2
+        Assert.True (view1.CanFocus);
+        Assert.False (view1.HasFocus); // Only one of the most focused toplevels view can have focus
+        Assert.True (view2.CanFocus);
+        Assert.True (view2.HasFocus);
+
+        Assert.True (Application.OnKeyDown (Key.F6));
+        Assert.True (view1.CanFocus);
+        Assert.True (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
+
+        view1.CanFocus = false;
+        Assert.False (view1.CanFocus);
+        Assert.False (view1.HasFocus);
+        Assert.True (view2.CanFocus);
+        Assert.False (view2.HasFocus);
+        Assert.Equal (win1, Application.Current.GetFocused ());
+        Assert.Equal (view12, Application.Current.GetMostFocused ());
+        top.Dispose ();
+    }
+#endif
+
+    [Fact (Skip = "Causes crash on Ubuntu in Github Action. Bogus test anyway.")]
+    public void WindowDispose_CanFocusProblem ()
+    {
+        // Arrange
+        Application.Init ();
+        using var top = new Toplevel ();
+        using var view = new View { X = 0, Y = 1, Text = nameof (WindowDispose_CanFocusProblem) };
+        using var window = new Window ();
+        top.Add (window);
+        window.Add (view);
+
+        // Act
+        RunState rs = Application.Begin (top);
+        Application.End (rs);
+        top.Dispose ();
+        Application.Shutdown ();
+
+        // Assert does Not throw NullReferenceException
+        top.SetFocus ();
+    }
+}

UnitTests/View/Navigation/HasFocusTests.cs

@@ -0,0 +1,160 @@
+using Xunit.Abstractions;
+
+namespace Terminal.Gui.ViewTests;
+
+public class HasFocusTests (ITestOutputHelper _output) : TestsAllViews
+{
+
+    [Fact]
+    public void HasFocus_False_Leaves ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+
+        view.HasFocus = false;
+        Assert.False (view.HasFocus);
+    }
+
+    [Fact]
+    public void HasFocus_False_WithSuperView_Leaves_All ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subview = new View ()
+        {
+            Id = "subview",
+            CanFocus = true
+        };
+        view.Add (subview);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.True (subview.HasFocus);
+
+        subview.HasFocus = false;
+        Assert.False (view.HasFocus);
+        Assert.False (subview.HasFocus);
+    }
+
+    [Fact]
+    public void HasFocus_False_WithSubview_Leaves_All ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subview = new View ()
+        {
+            Id = "subview",
+            CanFocus = true
+        };
+        view.Add (subview);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.True (subview.HasFocus);
+        Assert.Equal (subview, view.GetFocused ());
+
+        view.HasFocus = false;
+        Assert.Null (view.GetFocused ());
+        Assert.False (view.HasFocus);
+        Assert.False (subview.HasFocus);
+    }
+
+
+    [Fact]
+    public void HasFocus_False_Leave_Invoked ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+        Assert.True (view.CanFocus);
+        Assert.False (view.HasFocus);
+
+        int leaveInvoked = 0;
+
+        view.Leave += (s, e) => leaveInvoked++;
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.Equal (0, leaveInvoked);
+
+        view.HasFocus = false;
+        Assert.False (view.HasFocus);
+        Assert.Equal (1, leaveInvoked);
+    }
+
+    [Fact]
+    public void HasFocus_False_Leave_Invoked_ForAllSubViews ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subview = new View ()
+        {
+            Id = "subview",
+            CanFocus = true
+        };
+        view.Add (subview);
+
+        int leaveInvoked = 0;
+
+        view.Leave += (s, e) => leaveInvoked++;
+        subview.Leave += (s, e) => leaveInvoked++;
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.Equal (0, leaveInvoked);
+
+        view.HasFocus = false;
+        Assert.False (view.HasFocus);
+        Assert.False (subview.HasFocus);
+        Assert.Equal (2, leaveInvoked);
+    }
+
+
+    [Fact]
+    public void Enabled_False_Sets_HasFocus_To_False ()
+    {
+        var wasClicked = false;
+        var view = new Button { Text = "Click Me" };
+        view.Accept += (s, e) => wasClicked = !wasClicked;
+
+        view.NewKeyDownEvent (Key.Space);
+        Assert.True (wasClicked);
+        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Clicked });
+        Assert.False (wasClicked);
+        Assert.True (view.Enabled);
+        Assert.True (view.CanFocus);
+        Assert.True (view.HasFocus);
+
+        view.Enabled = false;
+        view.NewKeyDownEvent (Key.Space);
+        Assert.False (wasClicked);
+        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Clicked });
+        Assert.False (wasClicked);
+        Assert.False (view.Enabled);
+        Assert.True (view.CanFocus);
+        Assert.False (view.HasFocus);
+        view.SetFocus ();
+        Assert.False (view.HasFocus);
+    }
+
+}

UnitTests/View/Navigation/SetFocusTests.cs

@@ -0,0 +1,226 @@
+using Xunit.Abstractions;
+
+namespace Terminal.Gui.ViewTests;
+
+public class SetFocusTests (ITestOutputHelper _output) : TestsAllViews
+{
+   
+    [Fact]
+    public void SetFocus_With_Null_Superview_Does_Not_Throw_Exception ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+        Assert.True (view.CanFocus);
+        Assert.False (view.HasFocus);
+
+        Exception exception = Record.Exception (() => view.SetFocus ());
+        Assert.Null (exception);
+
+        Assert.True (view.CanFocus);
+        Assert.True (view.HasFocus);
+    }
+
+    [Fact]
+    public void SetFocus_SetsFocus ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+        Assert.True (view.CanFocus);
+        Assert.False (view.HasFocus);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+    }
+
+    [Fact]
+    public void SetFocus_NoSubView_Focused_Is_Null ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+        Assert.True (view.CanFocus);
+        Assert.False (view.HasFocus);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.Null (view.GetFocused ());
+    }
+
+    [Fact]
+    public void SetFocus_SubView_Focused_Is_Set ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subview = new View ()
+        {
+            Id = "subview",
+            CanFocus = true
+        };
+        view.Add (subview);
+        Assert.True (view.CanFocus);
+        Assert.False (view.HasFocus);
+
+        view.SetFocus ();
+        Assert.True (view.HasFocus);
+        Assert.Equal (subview, view.GetFocused ());
+    }
+
+    [Fact]
+    public void SetFocus_SetsFocus_DeepestSubView ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subview = new View ()
+        {
+            Id = "subview",
+            CanFocus = true
+        };
+        view.Add (subview);
+
+        view.SetFocus ();
+        Assert.True (subview.HasFocus);
+        Assert.Equal (subview, view.GetFocused ());
+    }
+
+    [Fact]
+    public void SetFocus_SetsFocus_DeepestSubView_CompoundSubView ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subView = new View ()
+        {
+            Id = "subView",
+            CanFocus = true
+        };
+
+        var subViewSubView1 = new View ()
+        {
+            Id = "subViewSubView1",
+            CanFocus = false
+        };
+
+        var subViewSubView2 = new View ()
+        {
+            Id = "subViewSubView2",
+            CanFocus = true
+        };
+        var subViewSubView3 = new View ()
+        {
+            Id = "subViewSubView3",
+            CanFocus = false
+        };
+        subView.Add (subViewSubView1, subViewSubView2, subViewSubView3);
+
+        view.Add (subView);
+
+        view.SetFocus ();
+        Assert.True (subView.HasFocus);
+        Assert.Equal (subView, view.GetFocused ());
+        Assert.Equal (subViewSubView2, subView.GetFocused ());
+    }
+
+    [Fact]
+    public void SetFocus_Peer_LeavesOther ()
+    {
+        var view = new View ()
+        {
+            Id = "view",
+            CanFocus = true
+        };
+
+        var subview1 = new View ()
+        {
+            Id = "subview1",
+            CanFocus = true
+        };
+
+        var subview2 = new View ()
+        {
+            Id = "subview2",
+            CanFocus = true
+        };
+        view.Add (subview1, subview2);
+
+        view.SetFocus ();
+        Assert.Equal (subview1, view.GetFocused ());
+        Assert.True (subview1.HasFocus);
+        Assert.False (subview2.HasFocus);
+
+        subview2.SetFocus ();
+        Assert.Equal (subview2, view.GetFocused ());
+        Assert.True (subview2.HasFocus);
+        Assert.False (subview1.HasFocus);
+    }
+
+    [Fact]
+    public void SetFocus_Peer_LeavesOthers_Subviews ()
+    {
+        var top = new View
+        {
+            Id = "top",
+            CanFocus = true
+        };
+        var view1 = new View
+        {
+            Id = "view1",
+            CanFocus = true
+        };
+
+        var subView1 = new View
+        {
+            Id = "subView1",
+            CanFocus = true
+        };
+
+        view1.Add (subView1);
+
+        var subView1SubView1 = new View
+        {
+            Id = "subView1subView1",
+            CanFocus = true
+        };
+
+        subView1.Add (subView1SubView1);
+
+        var view2 = new View
+        {
+            Id = "view2",
+            CanFocus = true
+        };
+
+        top.Add (view1, view2);
+        Assert.False (view1.HasFocus);
+        Assert.False (view2.HasFocus);
+
+        view1.SetFocus ();
+        Assert.True (view1.HasFocus);
+        Assert.True (subView1.HasFocus);
+        Assert.True (subView1SubView1.HasFocus);
+        Assert.Equal (subView1, view1.GetFocused ());
+        Assert.Equal (subView1SubView1, subView1.GetFocused ());
+
+        view2.SetFocus ();
+        Assert.False (view1.HasFocus);
+        Assert.True (view2.HasFocus);
+    }
+}