Nuked AlternateFwd/BkKeys.

Added Next/PrevTabGroupKey.
Fixed tests.

Terminal.Gui/Application/Application.Keyboard.cs

@@ -6,55 +6,55 @@ namespace Terminal.Gui;
 
 public static partial class Application // Keyboard handling
 {
-    private static Key _alternateForwardKey = Key.Empty; // Defined in config.json
+    private static Key _nextTabGroupKey = Key.Empty; // Defined in config.json
 
     /// <summary>Alternative key to navigate forwards through views. Ctrl+Tab is the primary key.</summary>
     [SerializableConfigurationProperty (Scope = typeof (SettingsScope))]
     [JsonConverter (typeof (KeyJsonConverter))]
-    public static Key AlternateForwardKey
+    public static Key NextTabGroupKey
     {
-        get => _alternateForwardKey;
+        get => _nextTabGroupKey;
         set
         {
-            if (_alternateForwardKey != value)
+            if (_nextTabGroupKey != value)
             {
-                Key oldKey = _alternateForwardKey;
-                _alternateForwardKey = value;
+                Key oldKey = _nextTabGroupKey;
+                _nextTabGroupKey = value;
 
-                if (_alternateForwardKey == Key.Empty)
+                if (_nextTabGroupKey == Key.Empty)
                 {
-                    KeyBindings.Remove (_alternateForwardKey);
+                    KeyBindings.Remove (_nextTabGroupKey);
                 }
                 else
                 {
-                    KeyBindings.ReplaceKey (oldKey, _alternateForwardKey);
+                    KeyBindings.ReplaceKey (oldKey, _nextTabGroupKey);
                 }
             }
         }
     }
 
-    private static Key _alternateBackwardKey = Key.Empty; // Defined in config.json
+    private static Key _prevTabGroupKey = Key.Empty; // Defined in config.json
 
     /// <summary>Alternative key to navigate backwards through views. Shift+Ctrl+Tab is the primary key.</summary>
     [SerializableConfigurationProperty (Scope = typeof (SettingsScope))]
     [JsonConverter (typeof (KeyJsonConverter))]
-    public static Key AlternateBackwardKey
+    public static Key PrevTabGroupKey
     {
-        get => _alternateBackwardKey;
+        get => _prevTabGroupKey;
         set
         {
-            if (_alternateBackwardKey != value)
+            if (_prevTabGroupKey != value)
             {
-                Key oldKey = _alternateBackwardKey;
-                _alternateBackwardKey = value;
+                Key oldKey = _prevTabGroupKey;
+                _prevTabGroupKey = value;
 
-                if (_alternateBackwardKey == Key.Empty)
+                if (_prevTabGroupKey == Key.Empty)
                 {
-                    KeyBindings.Remove (_alternateBackwardKey);
+                    KeyBindings.Remove (_prevTabGroupKey);
                 }
                 else
                 {
-                    KeyBindings.ReplaceKey (oldKey, _alternateBackwardKey);
+                    KeyBindings.ReplaceKey (oldKey, _prevTabGroupKey);
                 }
             }
         }
@@ -372,16 +372,14 @@ public static partial class Application // Keyboard handling
         KeyBindings.Add (Key.CursorDown, KeyBindingScope.Application, Command.NextView);
         KeyBindings.Add (Key.CursorLeft, KeyBindingScope.Application, Command.PreviousView);
         KeyBindings.Add (Key.CursorUp, KeyBindingScope.Application, Command.PreviousView);
-
         KeyBindings.Add (Key.Tab, KeyBindingScope.Application, Command.NextView);
         KeyBindings.Add (Key.Tab.WithShift, KeyBindingScope.Application, Command.PreviousView);
-        KeyBindings.Add (Key.Tab.WithCtrl, KeyBindingScope.Application, Command.NextViewOrTop);
-        KeyBindings.Add (Key.Tab.WithShift.WithCtrl, KeyBindingScope.Application, Command.PreviousViewOrTop);
+
+        KeyBindings.Add (Application.NextTabGroupKey, KeyBindingScope.Application, Command.NextViewOrTop); // Needed on Unix
+        KeyBindings.Add (Application.PrevTabGroupKey, KeyBindingScope.Application, Command.PreviousViewOrTop); // Needed on Unix
 
         // TODO: Refresh Key should be configurable
         KeyBindings.Add (Key.F5, KeyBindingScope.Application, Command.Refresh);
-        KeyBindings.Add (Application.AlternateForwardKey, KeyBindingScope.Application, Command.NextViewOrTop); // Needed on Unix
-        KeyBindings.Add (Application.AlternateBackwardKey, KeyBindingScope.Application, Command.PreviousViewOrTop); // Needed on Unix
 
         if (Environment.OSVersion.Platform == PlatformID.Unix)
         {

Terminal.Gui/Application/Application.cs

@@ -142,8 +142,8 @@ public static partial class Application
         UnGrabbedMouse = null;
 
         // Keyboard
-        AlternateBackwardKey = Key.Empty;
-        AlternateForwardKey = Key.Empty;
+        PrevTabGroupKey = Key.Empty;
+        NextTabGroupKey = Key.Empty;
         QuitKey = Key.Empty;
         KeyDown = null;
         KeyUp = null;

Terminal.Gui/Resources/config.json

@@ -17,8 +17,8 @@
   // to throw exceptions. 
   "ConfigurationManager.ThrowOnJsonErrors": false,
 
-  "Application.AlternateBackwardKey": "Ctrl+PageUp",
-  "Application.AlternateForwardKey": "Ctrl+PageDown",
+  "Application.NextTabGroupKey": "F6",
+  "Application.PrevTabGroupKey": "Shift+F6",
   "Application.QuitKey": "Esc",
 
   "Theme": "Default",

Terminal.Gui/View/View.Navigation.cs

@@ -818,10 +818,10 @@ public partial class View // Focus and cross-view navigation management (TabStop
     ///         focus even if this property is set and vice-versa.
     ///     </para>
     ///     <para>
-    ///         The default <see cref="TabBehavior.TabStop"/> keys are <c>Key.Tab</c> and <c>Key>Tab.WithShift</c>.
+    ///         The default <see cref="TabBehavior.TabStop"/> keys are <see cref="Application.NextTabKey"/> (<c>Key.Tab</c>) and <see cref="Application.PrevTabKey"/> (<c>Key>Tab.WithShift</c>).
     ///     </para>
     ///     <para>
-    ///         The default <see cref="TabBehavior.TabGroup"/> keys are <c>Key.Tab.WithCtrl</c> and <c>Key>Key.Tab.WithCtrl.WithShift</c>.
+    ///         The default <see cref="TabBehavior.TabGroup"/> keys are <see cref="Application.NextTabGroupKey"/> (<c>Key.F6</c>) and <see cref="Application.PrevTabGroupKey"/> (<c>Key>Key.F6.WithShift</c>).
     ///     </para>
     /// </remarks>
     public TabBehavior? TabStop

UnitTests/Application/ApplicationTests.cs

@@ -183,8 +183,8 @@ public class ApplicationTests
             Assert.Null (Application.Driver);
             Assert.Null (Application.MainLoop);
             Assert.False (Application.EndAfterFirstIteration);
-            Assert.Equal (Key.Empty, Application.AlternateBackwardKey);
-            Assert.Equal (Key.Empty, Application.AlternateForwardKey);
+            Assert.Equal (Key.Empty, Application.PrevTabGroupKey);
+            Assert.Equal (Key.Empty, Application.NextTabGroupKey);
             Assert.Equal (Key.Empty, Application.QuitKey);
             Assert.Null (ApplicationOverlapped.OverlappedChildren);
             Assert.Null (ApplicationOverlapped.OverlappedTop);
@@ -230,8 +230,8 @@ public class ApplicationTests
 
         //Application.ForceDriver = "driver";
         Application.EndAfterFirstIteration = true;
-        Application.AlternateBackwardKey = Key.A;
-        Application.AlternateForwardKey = Key.B;
+        Application.PrevTabGroupKey = Key.A;
+        Application.NextTabGroupKey = Key.B;
         Application.QuitKey = Key.C;
         Application.KeyBindings.Add (Key.A, KeyBindingScope.Application, Command.Cancel);
 

UnitTests/Application/KeyboardTests.cs

@@ -178,7 +178,7 @@ public class KeyboardTests
     }
 
     [Fact (Skip = "Replace when new key statics are added.")]
-    public void AlternateForwardKey_AlternateBackwardKey_Tests ()
+    public void NextTabGroupKey_PrevTabGroupKey_Tests ()
     {
         Application.Init (new FakeDriver ());
 
@@ -200,45 +200,27 @@ public class KeyboardTests
                                      Assert.True (v1.HasFocus);
 
                                      // Using default keys.
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
-                                     Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
-                                     Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
-                                     Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
-                                     Assert.True (v1.HasFocus);
-
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
-                                     Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
-                                     Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
-                                     Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
-                                     Assert.True (v1.HasFocus);
-
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v1.HasFocus);
 
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v1.HasFocus);
-
-                                     // Using another's alternate keys.
-                                     Application.AlternateForwardKey = Key.F7;
-                                     Application.AlternateBackwardKey = Key.F6;
+                                     
+                                     // Using alternate keys.
+                                     Application.NextTabGroupKey = Key.F7;
+                                     Application.PrevTabGroupKey = Key.F8;
 
                                      Application.OnKeyDown (Key.F7);
                                      Assert.True (v2.HasFocus);
@@ -249,13 +231,13 @@ public class KeyboardTests
                                      Application.OnKeyDown (Key.F7);
                                      Assert.True (v1.HasFocus);
 
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v1.HasFocus);
 
                                      Application.RequestStop ();
@@ -264,12 +246,12 @@ public class KeyboardTests
         Application.Run (top);
 
         // Replacing the defaults keys to avoid errors on others unit tests that are using it.
-        Application.AlternateForwardKey = Key.PageDown.WithCtrl;
-        Application.AlternateBackwardKey = Key.PageUp.WithCtrl;
+        Application.NextTabGroupKey = Key.PageDown.WithCtrl;
+        Application.PrevTabGroupKey = Key.PageUp.WithCtrl;
         Application.QuitKey = Key.Q.WithCtrl;
 
-        Assert.Equal (KeyCode.PageDown | KeyCode.CtrlMask, Application.AlternateForwardKey.KeyCode);
-        Assert.Equal (KeyCode.PageUp | KeyCode.CtrlMask, Application.AlternateBackwardKey.KeyCode);
+        Assert.Equal (KeyCode.PageDown | KeyCode.CtrlMask, Application.NextTabGroupKey.KeyCode);
+        Assert.Equal (KeyCode.PageUp | KeyCode.CtrlMask, Application.PrevTabGroupKey.KeyCode);
         Assert.Equal (KeyCode.Q | KeyCode.CtrlMask, Application.QuitKey.KeyCode);
 
         top.Dispose ();
@@ -321,14 +303,14 @@ public class KeyboardTests
         Assert.True (win2.HasFocus);
         Assert.Equal ("win2", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.True (win2.CanFocus);
         Assert.False (win.HasFocus);
         Assert.True (win2.CanFocus);
         Assert.True (win2.HasFocus);
         Assert.Equal ("win2", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.False (win.CanFocus);
         Assert.False (win.HasFocus);
         Assert.True (win2.CanFocus);
@@ -374,14 +356,14 @@ public class KeyboardTests
         Assert.False (win2.HasFocus);
         Assert.Equal ("win", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.True (win.CanFocus);
         Assert.False (win.HasFocus);
         Assert.True (win2.CanFocus);
         Assert.True (win2.HasFocus);
         Assert.Equal ("win2", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.True (win.CanFocus);
         Assert.True (win.HasFocus);
         Assert.True (win2.CanFocus);

UnitTests/Configuration/ConfigurationMangerTests.cs

@@ -33,14 +33,14 @@ public class ConfigurationManagerTests
 
             // assert
             Assert.Equal (KeyCode.Q, Application.QuitKey.KeyCode);
-            Assert.Equal (KeyCode.F, Application.AlternateForwardKey.KeyCode);
-            Assert.Equal (KeyCode.B, Application.AlternateBackwardKey.KeyCode);
+            Assert.Equal (KeyCode.F, Application.NextTabGroupKey.KeyCode);
+            Assert.Equal (KeyCode.B, Application.PrevTabGroupKey.KeyCode);
         }
 
         // act
         Settings ["Application.QuitKey"].PropertyValue = Key.Q;
-        Settings ["Application.AlternateForwardKey"].PropertyValue = Key.F;
-        Settings ["Application.AlternateBackwardKey"].PropertyValue = Key.B;
+        Settings ["Application.NextTabGroupKey"].PropertyValue = Key.F;
+        Settings ["Application.PrevTabGroupKey"].PropertyValue = Key.B;
 
         Apply ();
 
@@ -152,8 +152,8 @@ public class ConfigurationManagerTests
         Reset ();
 
         Settings ["Application.QuitKey"].PropertyValue = Key.Q;
-        Settings ["Application.AlternateForwardKey"].PropertyValue = Key.F;
-        Settings ["Application.AlternateBackwardKey"].PropertyValue = Key.B;
+        Settings ["Application.NextTabGroupKey"].PropertyValue = Key.F;
+        Settings ["Application.PrevTabGroupKey"].PropertyValue = Key.B;
 
         Updated += ConfigurationManager_Updated;
         var fired = false;
@@ -166,13 +166,13 @@ public class ConfigurationManagerTests
             Assert.Equal (Key.Esc, ((Key)Settings ["Application.QuitKey"].PropertyValue).KeyCode);
 
             Assert.Equal (
-                          KeyCode.PageDown | KeyCode.CtrlMask,
-                          ((Key)Settings ["Application.AlternateForwardKey"].PropertyValue).KeyCode
+                          KeyCode.F6,
+                          ((Key)Settings ["Application.NextTabGroupKey"].PropertyValue).KeyCode
                          );
 
             Assert.Equal (
-                          KeyCode.PageUp | KeyCode.CtrlMask,
-                          ((Key)Settings ["Application.AlternateBackwardKey"].PropertyValue).KeyCode
+                          KeyCode.F6 | KeyCode.ShiftMask,
+                          ((Key)Settings ["Application.PrevTabGroupKey"].PropertyValue).KeyCode
                          );
         }
 
@@ -229,14 +229,14 @@ public class ConfigurationManagerTests
         // arrange
         Reset ();
         Settings ["Application.QuitKey"].PropertyValue = Key.Q;
-        Settings ["Application.AlternateForwardKey"].PropertyValue = Key.F;
-        Settings ["Application.AlternateBackwardKey"].PropertyValue = Key.B;
+        Settings ["Application.NextTabGroupKey"].PropertyValue = Key.F;
+        Settings ["Application.PrevTabGroupKey"].PropertyValue = Key.B;
         Settings.Apply ();
 
         // assert apply worked
         Assert.Equal (KeyCode.Q, Application.QuitKey.KeyCode);
-        Assert.Equal (KeyCode.F, Application.AlternateForwardKey.KeyCode);
-        Assert.Equal (KeyCode.B, Application.AlternateBackwardKey.KeyCode);
+        Assert.Equal (KeyCode.F, Application.NextTabGroupKey.KeyCode);
+        Assert.Equal (KeyCode.B, Application.PrevTabGroupKey.KeyCode);
 
         //act
         Reset ();
@@ -245,13 +245,13 @@ public class ConfigurationManagerTests
         Assert.NotEmpty (Themes);
         Assert.Equal ("Default", Themes.Theme);
         Assert.Equal (Key.Esc, Application.QuitKey);
-        Assert.Equal (KeyCode.PageDown | KeyCode.CtrlMask, Application.AlternateForwardKey.KeyCode);
-        Assert.Equal (KeyCode.PageUp | KeyCode.CtrlMask, Application.AlternateBackwardKey.KeyCode);
+        Assert.Equal (Key.F6, Application.NextTabGroupKey);
+        Assert.Equal (Key.F6.WithShift, Application.PrevTabGroupKey);
 
         // arrange
         Settings ["Application.QuitKey"].PropertyValue = Key.Q;
-        Settings ["Application.AlternateForwardKey"].PropertyValue = Key.F;
-        Settings ["Application.AlternateBackwardKey"].PropertyValue = Key.B;
+        Settings ["Application.NextTabGroupKey"].PropertyValue = Key.F;
+        Settings ["Application.PrevTabGroupKey"].PropertyValue = Key.B;
         Settings.Apply ();
 
         Locations = ConfigLocations.DefaultOnly;
@@ -264,8 +264,8 @@ public class ConfigurationManagerTests
         Assert.NotEmpty (Themes);
         Assert.Equal ("Default", Themes.Theme);
         Assert.Equal (KeyCode.Esc, Application.QuitKey.KeyCode);
-        Assert.Equal (KeyCode.PageDown | KeyCode.CtrlMask, Application.AlternateForwardKey.KeyCode);
-        Assert.Equal (KeyCode.PageUp | KeyCode.CtrlMask, Application.AlternateBackwardKey.KeyCode);
+        Assert.Equal (Key.F6, Application.NextTabGroupKey);
+        Assert.Equal (Key.F6.WithShift, Application.PrevTabGroupKey);
         Reset ();
     }
 

UnitTests/Configuration/SettingsScopeTests.cs

@@ -12,26 +12,26 @@ public class SettingsScopeTests
         Assert.Equal (Key.Esc, (Key)Settings ["Application.QuitKey"].PropertyValue);
 
         Assert.Equal (
-                      KeyCode.PageDown | KeyCode.CtrlMask,
-                      ((Key)Settings ["Application.AlternateForwardKey"].PropertyValue).KeyCode
+                      Key.F6,
+                      (Key)Settings ["Application.NextTabGroupKey"].PropertyValue
                      );
 
         Assert.Equal (
-                      KeyCode.PageUp | KeyCode.CtrlMask,
-                      ((Key)Settings ["Application.AlternateBackwardKey"].PropertyValue).KeyCode
+                      Key.F6.WithShift,
+                      (Key)Settings["Application.PrevTabGroupKey"].PropertyValue
                      );
 
         // act
         Settings ["Application.QuitKey"].PropertyValue = Key.Q;
-        Settings ["Application.AlternateForwardKey"].PropertyValue = Key.F;
-        Settings ["Application.AlternateBackwardKey"].PropertyValue = Key.B;
+        Settings ["Application.NextTabGroupKey"].PropertyValue = Key.F;
+        Settings ["Application.PrevTabGroupKey"].PropertyValue = Key.B;
 
         Settings.Apply ();
 
         // assert
         Assert.Equal (KeyCode.Q, Application.QuitKey.KeyCode);
-        Assert.Equal (KeyCode.F, Application.AlternateForwardKey.KeyCode);
-        Assert.Equal (KeyCode.B, Application.AlternateBackwardKey.KeyCode);
+        Assert.Equal (KeyCode.F, Application.NextTabGroupKey.KeyCode);
+        Assert.Equal (KeyCode.B, Application.PrevTabGroupKey.KeyCode);
     }
 
     [Fact]
@@ -39,18 +39,17 @@ public class SettingsScopeTests
     public void CopyUpdatedPropertiesFrom_ShouldCopyChangedPropertiesOnly ()
     {
         Settings ["Application.QuitKey"].PropertyValue = Key.End;
-        ;
 
         var updatedSettings = new SettingsScope ();
 
         ///Don't set Quitkey
-        updatedSettings ["Application.AlternateForwardKey"].PropertyValue = Key.F;
-        updatedSettings ["Application.AlternateBackwardKey"].PropertyValue = Key.B;
+        updatedSettings ["Application.NextTabGroupKey"].PropertyValue = Key.F;
+        updatedSettings ["Application.PrevTabGroupKey"].PropertyValue = Key.B;
 
         Settings.Update (updatedSettings);
         Assert.Equal (KeyCode.End, ((Key)Settings ["Application.QuitKey"].PropertyValue).KeyCode);
-        Assert.Equal (KeyCode.F, ((Key)updatedSettings ["Application.AlternateForwardKey"].PropertyValue).KeyCode);
-        Assert.Equal (KeyCode.B, ((Key)updatedSettings ["Application.AlternateBackwardKey"].PropertyValue).KeyCode);
+        Assert.Equal (KeyCode.F, ((Key)updatedSettings ["Application.NextTabGroupKey"].PropertyValue).KeyCode);
+        Assert.Equal (KeyCode.B, ((Key)updatedSettings ["Application.PrevTabGroupKey"].PropertyValue).KeyCode);
     }
 
     [Fact]
@@ -65,8 +64,8 @@ public class SettingsScopeTests
         Assert.Equal ("Default", Themes.Theme);
 
         Assert.True (Settings ["Application.QuitKey"].PropertyValue is Key);
-        Assert.True (Settings ["Application.AlternateForwardKey"].PropertyValue is Key);
-        Assert.True (Settings ["Application.AlternateBackwardKey"].PropertyValue is Key);
+        Assert.True (Settings ["Application.NextTabGroupKey"].PropertyValue is Key);
+        Assert.True (Settings ["Application.PrevTabGroupKey"].PropertyValue is Key);
 
         Assert.True (Settings ["Theme"].PropertyValue is string);
         Assert.Equal ("Default", Settings ["Theme"].PropertyValue as string);

UnitTests/View/NavigationTests.cs

@@ -319,13 +319,13 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         Assert.True (view2.CanFocus);
         Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl));
+        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.Tab.WithCtrl));
+        Assert.True (Application.OnKeyDown (Key.F6));
         Assert.True (view1.CanFocus);
         Assert.True (view1.HasFocus);
         Assert.True (view2.CanFocus);
@@ -360,13 +360,13 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         Assert.True (view2.CanFocus);
         Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl));
+        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.Tab.WithCtrl));
+        Assert.True (Application.OnKeyDown (Key.F6));
         Assert.True (view1.CanFocus);
         Assert.True (view1.HasFocus);
         Assert.True (view2.CanFocus);
@@ -412,13 +412,13 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         Assert.True (view2.CanFocus);
         Assert.False (view2.HasFocus); // Only one of the most focused toplevels view can have focus
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl)); // move to win2
+        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.Tab.WithCtrl));
+        Assert.True (Application.OnKeyDown (Key.F6));
         Assert.True (view1.CanFocus);
         Assert.True (view1.HasFocus);
         Assert.True (view2.CanFocus);
@@ -545,19 +545,19 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         Application.OnKeyDown (Key.Tab);
         Assert.Equal ("WindowSubview", top.MostFocused.Text);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.Equal ("FrameSubview", top.MostFocused.Text);
 
         Application.OnKeyDown (Key.Tab);
         Assert.Equal ("FrameSubview", top.MostFocused.Text);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.Equal ("WindowSubview", top.MostFocused.Text);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl.WithShift);
+        Application.OnKeyDown (Key.F6.WithShift);
         Assert.Equal ("FrameSubview", top.MostFocused.Text);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl.WithShift);
+        Application.OnKeyDown (Key.F6.WithShift);
         Assert.Equal ("WindowSubview", top.MostFocused.Text);
         top.Dispose ();
     }
@@ -609,14 +609,14 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         Assert.False (removed);
         Assert.Null (view3);
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl));
+        Assert.True (Application.OnKeyDown (Key.F6));
         Assert.True (top1.HasFocus);
         Assert.False (view1.HasFocus);
         Assert.True (view2.HasFocus);
         Assert.True (removed);
         Assert.NotNull (view3);
 
-        Exception exception = Record.Exception (() => Application.OnKeyDown (Key.Tab.WithCtrl));
+        Exception exception = Record.Exception (() => Application.OnKeyDown (Key.F6));
         Assert.Null (exception);
         Assert.True (removed);
         Assert.Null (view3);
@@ -1689,7 +1689,7 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         // Use keyboard to navigate to next view (otherView).
         if (view is TextView)
         {
-            Application.OnKeyDown (Key.Tab.WithCtrl);
+            Application.OnKeyDown (Key.F6);
         }
         else
         {
@@ -1710,7 +1710,7 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
                         Application.OnKeyDown (Key.Tab);
                         break;
                     case TabBehavior.TabGroup:
-                        Application.OnKeyDown (Key.Tab.WithCtrl);
+                        Application.OnKeyDown (Key.F6);
                         break;
                     case null:
                         Application.OnKeyDown (Key.Tab);
@@ -1737,7 +1737,7 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
                 Application.OnKeyDown (Key.Tab);
                 break;
             case TabBehavior.TabGroup:
-                Application.OnKeyDown (Key.Tab.WithCtrl);
+                Application.OnKeyDown (Key.F6);
                 break;
             case null:
                 Application.OnKeyDown (Key.Tab);
@@ -1832,13 +1832,13 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         // Use keyboard to navigate to next view (otherView). 
         if (view is TextView)
         {
-            Application.OnKeyDown (Key.Tab.WithCtrl);
+            Application.OnKeyDown (Key.F6);
         }
         else if (view is DatePicker)
         {
             for (var i = 0; i < 4; i++)
             {
-                Application.OnKeyDown (Key.Tab.WithCtrl);
+                Application.OnKeyDown (Key.F6);
             }
         }
         else
@@ -1899,7 +1899,7 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
 
         if (view.TabStop == TabBehavior.TabGroup)
         {
-            navKeys = new Key [] { Key.Tab.WithCtrl, Key.Tab.WithCtrl.WithShift };
+            navKeys = new Key [] { Key.F6, Key.F6.WithShift };
         }
 
         bool left = false;

UnitTests/Views/OverlappedTests.cs

@@ -1116,10 +1116,10 @@ public class OverlappedTests
         Assert.True (Application.OnKeyDown (Key.Tab.WithShift));
         Assert.Equal ($"First line Win1{Environment.NewLine}Second line Win1", tvW1.Text);
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl));    // move to win2
+        Assert.True (Application.OnKeyDown (Key.F6));    // move to win2
         Assert.Equal (win2, ApplicationOverlapped.OverlappedChildren [0]);
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl.WithShift));    // move back to win1
+        Assert.True (Application.OnKeyDown (Key.F6.WithShift));    // move back to win1
         Assert.Equal (win1, ApplicationOverlapped.OverlappedChildren [0]);
 
         Assert.Equal (tvW1, win1.MostFocused);
@@ -1156,19 +1156,19 @@ public class OverlappedTests
         Assert.Equal (win1, ApplicationOverlapped.OverlappedChildren [0]);
         Assert.Equal (tf2W1, win1.MostFocused);
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl)); // Move to win2
+        Assert.True (Application.OnKeyDown (Key.F6)); // Move to win2
         Assert.Equal (win2, ApplicationOverlapped.OverlappedChildren [0]);
         Assert.Equal (tf1W2, win2.MostFocused);
         tf2W2.SetFocus ();
         Assert.True (tf2W2.HasFocus);
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl.WithShift));
+        Assert.True (Application.OnKeyDown (Key.F6.WithShift));
         Assert.Equal (win1, ApplicationOverlapped.OverlappedChildren [0]);
         Assert.Equal (tf2W1, win1.MostFocused);
-        Assert.True (Application.OnKeyDown (Application.AlternateForwardKey));
+        Assert.True (Application.OnKeyDown (Application.NextTabGroupKey));
         Assert.Equal (win2, ApplicationOverlapped.OverlappedChildren [0]);
         Assert.Equal (tf2W2, win2.MostFocused);
-        Assert.True (Application.OnKeyDown (Application.AlternateBackwardKey));
+        Assert.True (Application.OnKeyDown (Application.PrevTabGroupKey));
         Assert.Equal (win1, ApplicationOverlapped.OverlappedChildren [0]);
         Assert.Equal (tf2W1, win1.MostFocused);
         Assert.True (Application.OnKeyDown (Key.CursorDown));

UnitTests/Views/TextViewTests.cs

@@ -5407,10 +5407,10 @@ This is the second line.
                       tv.Text
                      );
         Assert.True (tv.AllowsTab);
-        Assert.False (tv.NewKeyDownEvent (Key.Tab.WithCtrl));
-        Assert.False (tv.NewKeyDownEvent (Application.AlternateForwardKey));
-        Assert.False (tv.NewKeyDownEvent (Key.Tab.WithCtrl.WithShift));
-        Assert.False (tv.NewKeyDownEvent (Application.AlternateBackwardKey));
+        Assert.False (tv.NewKeyDownEvent (Key.F6));
+        Assert.False (tv.NewKeyDownEvent (Application.NextTabGroupKey));
+        Assert.False (tv.NewKeyDownEvent (Key.F6.WithShift));
+        Assert.False (tv.NewKeyDownEvent (Application.PrevTabGroupKey));
 
         Assert.True (tv.NewKeyDownEvent (ContextMenu.DefaultKey));
         Assert.True (tv.ContextMenu != null && tv.ContextMenu.MenuBar.Visible);

UnitTests/Views/ToplevelTests.cs

@@ -486,10 +486,10 @@ public partial class ToplevelTests (ITestOutputHelper output)
 
         var prevMostFocusedSubview = top.MostFocused;
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl)); // move to next TabGroup (win2)
+        Assert.True (Application.OnKeyDown (Key.F6)); // move to next TabGroup (win2)
         Assert.Equal (win2, top.Focused);
 
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl.WithShift)); // move to prev TabGroup (win1)
+        Assert.True (Application.OnKeyDown (Key.F6.WithShift)); // move to prev TabGroup (win1)
         Assert.Equal (win1, top.Focused);
         Assert.Equal (tf2W1, top.MostFocused);  // BUGBUG: Should be prevMostFocusedSubview - We need to cache the last focused view in the TabGroup somehow
 
@@ -527,16 +527,16 @@ public partial class ToplevelTests (ITestOutputHelper output)
         Assert.Equal (tvW1, top.MostFocused);
 
         // nav to win2
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl));
+        Assert.True (Application.OnKeyDown (Key.F6));
         Assert.Equal (win2, top.Focused);
         Assert.Equal (tf1W2, top.MostFocused);
-        Assert.True (Application.OnKeyDown (Key.Tab.WithCtrl.WithShift));
+        Assert.True (Application.OnKeyDown (Key.F6.WithShift));
         Assert.Equal (win1, top.Focused);
         Assert.Equal (tf2W1, top.MostFocused);
-        Assert.True (Application.OnKeyDown (Application.AlternateForwardKey));
+        Assert.True (Application.OnKeyDown (Application.NextTabGroupKey));
         Assert.Equal (win2, top.Focused);
         Assert.Equal (tf1W2, top.MostFocused);
-        Assert.True (Application.OnKeyDown (Application.AlternateBackwardKey));
+        Assert.True (Application.OnKeyDown (Application.PrevTabGroupKey));
         Assert.Equal (win1, top.Focused);
         Assert.Equal (tf2W1, top.MostFocused);
         Assert.True (Application.OnKeyDown (Key.CursorUp));

docfx/docs/config.md

@@ -33,12 +33,14 @@ The `UI Catalog` application provides an example of how to use the [`Configurati
 (Note, this list may not be complete; search the source code for `SerializableConfigurationProperty` to find all settings that can be configured.)
 
   * [Application.QuitKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_QuitKey)
-  * [Application.AlternateForwardKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_AlternateForwardKey)
-  * [Application.AlternateBackwardKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_AlternateBackwardKey)
-  * [Application.UseSystemConsole](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_UseSystemConsole)
+  * [Application.NextTabKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_NextTabKey)
+  * [Application.PrevTabKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_PrevTabKey)
+  * [Application.NextTabGroupKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_NextTabGroupKey)
+  * [Application.PrevTabGroupKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_PrevTabGroupKey)
+  * [Application.ForceDriver](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_ForceDriver)
+  * [Application.Force16Colors](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_Force16Colors)
   * [Application.IsMouseDisabled](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_IsMouseDisabled)
-  * [Application.EnableConsoleScrolling](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_EnableConsoleScrolling)
-
+  
 ## Glyphs
 
 The standard set of glyphs used for standard views (e.g. the default indicator for [Button](~/api/Terminal.Gui.Button.yml)) and line drawing (e.g. [LineCanvas](~/api/Terminal.Gui.LineCanvas.yml)) can be configured.

docfx/docs/keyboard.md

@@ -37,6 +37,8 @@ The [Command](~/api/Terminal.Gui.Command.yml) enum lists generic operations that
 firing while in `TableView` it is bound to `CellActivated`. Not all commands
 are implemented by all views (e.g. you cannot scroll in a `Button`). Use the `GetSupportedCommands()` method to determine which commands are implemented by a `View`. 
 
+Key Bindings can be added at the Application or View level. For Application-scoped Key Bindings see [ApplicationNavigation](~/api/Terminal.Gui.ApplicationNavigation.yml). For View-scoped Key Bindings see [Key Bindings](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_KeyBinings).
+
 ### **[HotKey](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_HotKey)** 
 
 A **HotKey** is a keypress that selects a visible UI item. For selecting items across `View`s (e.g. a `Button` in a `Dialog`) the keypress must have the `Alt` modifier. For selecting items within a `View` that are not `View`s themselves, the keypress can be key without the `Alt` modifier.  For example, in a `Dialog`, a `Button` with the text of "_Text" can be selected with `Alt-T`. Or, in a `Menu` with "_File _Edit", `Alt-F` will select (show) the "_File" menu. If the "_File" menu has a sub-menu of "_New" `Alt-N` or `N` will ONLY select the "_New" sub-menu if the "_File" menu is already opened.