Keyboard Deep Dive | Terminal.Gui v2 (original) (raw)

See Also

Tenets for Terminal.Gui Keyboard Handling (Unless you know better ones...)

Tenets higher in the list have precedence over tenets lower in the list.

Keyboard APIs

Terminal.Gui provides the following APIs for handling keyboard input:

Each of these APIs are described more fully below.

Key Bindings

Key Bindings is the preferred way of handling keyboard input in View implementations. The View calls AddCommand(Command, Func<bool?>) to declare it supports a particular command and then uses KeyBindings to indicate which key presses will invoke the command. For example, if a View wants to respond to the user pressing the up arrow key to scroll up it would do this

public MyView : View
{
  AddCommand (Command.ScrollUp, () => ScrollVertical (-1));
  KeyBindings.Add (Key.CursorUp, Command.ScrollUp);
}

The Character Map Scenario includes a View called CharMap that is a good example of the Key Bindings API.

The Command enum lists generic operations that are implemented by views. For example Command.Accept in a Button results in the Accepting event 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.

The default key for activating a button is Space. You can change this usingKeyBindings.ReplaceKey():

var btn = new Button () { Title = "Press me" };
btn.KeyBindings.ReplaceKey (btn.KeyBindings.GetKeyFromCommands (Command.Accept));

Key Bindings can be added at the Application or View level.

For Application-scoped Key Bindings there are two categories of Application-scoped Key Bindings:

  1. Application Command Key Bindings - Bindings for Commands supported by Application. For example, QuitKey, which is bound to Command.Quit and results in RequestStop(Toplevel?) being called.
  2. Application Key Bindings - Bindings for Commands supported on arbitrary Views that are meant to be invoked regardless of which part of the application is visible/active.

Use KeyBindings to add or modify Application-scoped Key Bindings.

View-scoped Key Bindings also have two categories:

  1. HotKey Bindings - These bind to Commands that will be invoked regardless of whether the View has focus or not. The most common use-case for HotKey bindings is HotKey. For example, a Button with a Title of _OK, the user can press Alt-O and the button will be accepted regardless of whether it has focus or not. Add and modify HotKey bindings with HotKeyBindings.
  2. Focused Bindings - These bind to Commands that will be invoked only when the View has focus. Focused Key Bindings are the easiest way to enable a View to support responding to key events. Add and modify Focused bindings with KeyBindings.

Application-Scoped Key Bindings

HotKey

A HotKey is a key press that selects a visible UI item. For selecting items across Views (e.g. a Button in a Dialog) the key press must have the Alt modifier. For selecting items within a View that are not Views themselves, the key press 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.

By default, the Text of a View is used to determine the HotKey by looking for the first occurrence of the HotKeySpecifier (which is underscore (_) by default). The character following the underscore is the HotKey. If the HotKeySpecifier is not found in Text, the first character of Text is used as the HotKey. The Text of a View can be changed at runtime, and the HotKey will be updated accordingly. HotKey is virtual enabling this behavior to be customized.

Shortcut

A Shortcut is an opinionated (visually & API) View for displaying a command, help text, key key press that invokes a Command.

The Command can be invoked even if the View that defines them is not focused or visible (but the View must be enabled). Shortcuts can be any key press; Key.A, Key.A.WithCtrl, Key.A.WithCtrl.WithAlt, Key.Del, and Key.F1, are all valid.

Shortcuts are used to define application-wide actions or actions that are not visible (e.g. Copy).

MenuBar, ContextMenu, and StatusBar support Shortcuts.

Key Events

Keyboard events are retrieved from Console Drivers each iteration of the Application Main Loop. The console driver raises the KeyDown and KeyUp events which invoke RaiseKeyDownEvent(Key) and RaiseKeyUpEvent(Key) respectively.

Note

Not all drivers/platforms support sensing distinct KeyUp events. These drivers will simulate KeyUp events by raising KeyUp after KeyDown.

RaiseKeyDownEvent(Key) raises KeyDown and then calls NewKeyDownEvent(Key) on all toplevel Views. If no View handles the key event, any Application-scoped key bindings will be invoked.

If a view is enabled, the NewKeyDownEvent(Key) method will do the following:

  1. If the view has a subview that has focus, 'NewKeyDown' on the focused view will be called. This is recursive. If the most-focused view handles the key press, processing stops.
  2. If there is no most-focused sub-view, or a most-focused sub-view does not handle the key press, OnKeyDown(Key) will be called. If the view handles the key press, processing stops.
  3. If OnKeyDown(Key) does not handle the event. KeyDown will be raised.
  4. If the view does not handle the key down event, any bindings for the key will be invoked (see the KeyBindings property). If the key is bound and any of it's command handlers return true, processing stops.
  5. If the key is not bound, or the bound command handlers do not return true, OnKeyDownNotHandled(Key) is called.

Application Key Handling

To define application key handling logic for an entire application in cases where the methods listed above are not suitable, use the KeyDown event.

Key Down/Up Events

Terminal.Gui supports key up/down events with OnKeyDown(Key) and OnKeyUp(Key), but not all Console Drivers do. To receive these key down and key up events, you must use a driver that supports them (e.g. WindowsDriver).

General input model

ConsoleDriver

Application

View