~~~~~~~~~~
Key Tables
~~~~~~~~~~

.. include:: prologue.rst

Description
===========

Files with names of the form ``*.ktb`` are key tables, and with names of the
form ``*.kti`` are key subtables. They are used to bind braille device and
computer keyboard key combinations to BRLTTY commands.

*  Braille device key tables can usually be found in the
   ``/etc/brltty/Input/xx/`` directory, where ``xx`` is the two-letter braille
   driver identification code (see `Braille Driver List`_). The name of a
   braille device key table identifies the model(s) for which it is used. The
   driver selects which key table is to be used.

*  Computer keyboard key tables can usually be found in the
   ``/etc/brltty/Keyboard/`` directory. The name of a keyboard key table
   describes the kind of keyboard for which it has been designed. See
   `Keyboard Table List`_ for a list of BRLTTY's keyboard tables.

*  See |README.Customize| for more details regarding key table locations.

A key table consists of a sequence of directives, one per line, which define 
how keys and key combinations are to be interpreted. UTF-8 character encoding 
must be used. Whitespace (blanks, tabs) at the beginning of a line, as well as 
before and/or after any operand, is ignored. Lines containing only whitespace 
are ignored. If the first non-whitespace character of a line is ``#`` then
that line is a comment and is ignored.

The precedence for resolving each key press/release event is as follows:

1) A hotkey press or release defined within the current context.
2) A key combination defined within the current context.
3) A braille keyboard command defined within the current context.
4) A key combination defined within the default context.

Directives
==========

.. |key operand| replace::
   The name of the key whose availability is to be tested.

.. |platform operand| replace::
   The name of a host platform.
   The following platform names are recognized:
   android, apple, cygwin, dos, grub, linux,
   mingw32, mingw64, openbsd, sun, windows.

The Bind Directive
------------------

.. parsed-literal:: bind *keys* *commands*

Use this directive to define which BRLTTY command is executed when a particular
combination of keys is pressed. The binding is defined within the current
context.

*keys*
   The key combination which is to be bound. It's a sequence of one or more key
   and/or key group names separated by plus (``+``) signs. The final (or only)
   key name may be optionally prefixed with an exclamation (``!``) point. For
   example::

      key1
      group1
      key1+key2
      key1+key2+group1
      !group1
      key1+!key2

   A key group name refers to any key within the named group. A specific key
   within the group may be identified by appending a dot (``.``) and a number
   to the group's name. The first key within a group is key #1 (e.g.
   ``keyGroupName.1``).

   The keys may be pressed in any order, with the exception that if the final
   key name is prefixed with an exclamation point then it must be pressed last.
   The exclamation point prefix means that the primary command (see below) is
   executed as soon as that key is pressed. If not used, the primary command is
   executed as soon as any of the keys is released.

*commands*
   The primary and secondary BRLTTY commands that are to be bound to the key
   combination. The two commands (primary first and secondary last) are
   separated from one another by a colon (``:``). Both commands are optional.
   If just a primary command is being bound then the colon needn't be supplied.
   All of these are valid:

   *  bind key primaryCommand
   *  bind key primaryCommand:
   *  bind key primaryCommand:secondaryCommand
   *  bind key :secondaryCommand
   *  bind key :

   The primary command is executed as described above. The secondary command is
   executed if the key combination is held for a while (i.e. when a long key
   press is detected). If the **autorepeat** feature is enabled then the
   secondary command is autorepeated if it has been defined, else the primary
   command is autorepeated.

   For a list of commands, see |README.CommandReference|.

.. _Bind Command Modifiers:

One or more modifiers may be optionally appended to a command name by using a 
plus (``+``) sign as the separator. For example::

   bind key command
   bind key command+modifier1
   bind key command+modifier1+modifier2

For commands which enable/disable a feature:

*  If the modifier ``+on`` is specified then the feature is enabled.
*  If the modifier ``+off`` is specified then the feature is disabled.
*  If neither ``+on`` nor ``+off`` is specified then the state of the feature
   is toggled on/off.

For commands which move the braille window:

*  If the modifier ``+route`` is specified then, if necessary, the screen
   cursor is automatically routed so that it's always visible on the braille
   display.

For commands which move the braille window to a specific line on the screen:

*  If the modifier ``+toleft`` is specified then the braille window is also
   moved to the beginning of that line.
*  If the modifier ``+scaled`` is specified then the key group bound to the 
   command is interpreted as though it were a scroll bar. If it isn't
   specified then there's a one-to-one correspondence between keys and lines.

For commands which require an offset:

*  The modifier ``+offset``, where ``offset`` is a non-negative integer, may be
   specified. If it isn't specified then ``+0`` is assumed.

For commands which input any keyboard key (print or braille): 

*  The ``+shift`` modifier adds the shift key.
*  The ``+control`` modifier adds the control key.
*  The ``+meta`` modifier adds the left alt (or meta) key.
*  The ``+altgr`` modifier adds the right alt (or altgr) key.
*  The ``+gui`` modifier adds the gui (or windows) key.

For commands which input characters (print or braille):

*  The modifier ``+upper`` converts a lowercase character to uppercase.

For commands which input braille characters:

*  The modifiers ``+dot1`` through ``+dot8`` add those dots to the character.
*  The modifier ``+space`` adds the space bar (or "chord" key) to the
   character.

For commands which input keyboard scancodes:

*  The ``+release`` modifier means that it's a key release scancode. If it
   isn't specified then it's a key press scancode (unless, of course, the
   scancode itself indicates something else).
*  The ``+emul0`` modifier means that it's an emulation mode 0 scancode.
*  The ``+emul1`` modifier means that it's an emulation mode 1 scancode.

Examples::

   bind Key1 CSRTRK
   bind Key1+Key2 CSRTRK+off
   bind Key1+Key3 CSRTRK+on
   bind Key4 TOP
   bind Key5 TOP+route
   bind VerticalSensor GOTOLINE+toleft+scaled
   bind Key6 CONTEXT+context1

The Context Directive
---------------------

.. parsed-literal:: context *name* *title*

Use this directive to define alternate ways to interpret certain key events
and/or combinations.
Switching to another context is done via the BRLTTY command CONTEXT+name.

A context contains definitions created by any of:

*  `The Bind Directive`_
*  `The Hotkey Directive`_
*  `The Ignore Directive`_
*  `The Macro Directive`_
*  `The Map Directive`_
*  `The Run Directive`_
*  `The Superimpose Directive`_

*name*
   Which context subsequent definitions are to be created within.

*title*
   A person-readable description of the context. It may contain spaces.
   Standard capitalization conventions should be used. This operand is
   optional. If supplied when selecting a context which already has a title
   then the two must match. Special contexts already have internally-assigned
   titles.

A context is created the first time it's selected. It may be reselected any
number of times thereafter. These special contexts are predefined:

``default``
   The default context. If a definition can't be found within the current
   context then it's looked up within the default context. This only applies
   to definitions created by:

   *  `The Bind Directive`_.
   *  `The Macro Directive`_.
   *  `The Run Directive`_.

``menu``
   This context is used when within BRLTTY's Preferences Menu.

All subsequent definitions until either the next ``context`` directive or the
end of the current include level are created within the selected context. The 
initial context of the top-level key table is ``default``. The initial context
of an included key subtable is the context which was selected when it was 
included. Context changes within included key subtables don't affect the 
context of the including key table or subtable.

If a context has a title then it is persistent. When a key event causes a
persistent context to be activated, that context remains current until a
subsequent key event causes a different persistent context to be activated.

If a context doesn't have a title then it is temporary. When a key event causes
a temporary context to be activated, that context is only used to interpret the 
very next key event.

Examples::

   context menu
   context braille Braille Input
   context DESCCHAR

The Hide Directive
------------------

.. parsed-literal:: hide *state*

Use this directive to specify whether or not definitions created by:

*  `The Bind Directive`_
*  `The Hotkey Directive`_
*  `The Map Directive`_
*  `The Superimpose Directive`_

and text added by:

*  `The Note Directive`_

are to be included within the key table's help text.

*state*
   One of these keywords:

   ``on``
      They're excluded.
   ``off``
      They're included.

The specified hide state applies to all subsequent definitions and notes until 
either the next ``hide`` directive or the end of the current include level. The
initial hide state of the top-level key table is ``off``. The initial hide
state of an included key subtable is the hide state that was in effect when it
was included. Hide State changes within included key subtables don't affect the
hide state of the including key table or subtable.

Examples::

   hide on

The Hotkey Directive
--------------------

.. parsed-literal:: hotkey *key* *press* *release*

Use this directive to bind the press and release events of a specific key to
two separate BRLTTY commands. The bindings are defined within the current
context.

*key*
   The name of the key which is to be bound.

*press*
   The name of the BRLTTY command which is to be executed whenever the key is
   pressed.

*release*
   The name of the BRLTTY command which is to be executed whenever the key is
   released.

Modifiers may be appended to the command names. See
`Bind Command Modifiers`_ for details.

Specify the ``NOOP`` command if no command is to be executed. Specifying the
``NOOP`` command for both events effectively disables the key.

Examples::

   hotkey Key1 CSRVIS+off CSRVIS+on
   hotkey Key2 NOOP NOOP

The IfKey Directive
-------------------

.. parsed-literal:: ifKey *key* *directive*

Use this directive to only process one or more directives if the device has a
particular key.

*key*
   |key operand|

*directive*
   |directive operand|

Examples::

   ifKey Key1 ifkey Key2 bind Key1+Key2 HOME

The IfNotKey Directive
----------------------

.. parsed-literal:: ifNotKey *key* *directive*

Use this directive to only process one or more directives if the device doesn't
have a particular key.

*key*
   |key operand|

*directive*
   |directive operand|

Examples::

   ifNotKey Key2 bind Key1 HOME

The IfPlatform Directive
------------------------

.. parsed-literal:: ifPlatform *platform* *directive*

Use this directive to only process one or more directives if running on the
named host platform.

*platform*
   |platform operand|

*directive*
   |directive operand|

Examples::

   ifPlatform android include android.kti

The IfNotPlatform Directive
---------------------------

.. parsed-literal:: ifNotPlatform *platform* *directive*

Use this directive to only process one or more directives if not running on
the named host platform.

*platform*
   |platform operand|

*directive*
   |directive operand|

Examples::

   ifNotPlatform grub include advanced.kti

The Ignore Directive
--------------------

.. parsed-literal:: ignore *key*

Use this directive to ignore a specific key while within the current context.

*key*
   The name of the key which is to be ignored.

Examples::

   ignore Key1

The Isolated Directive
----------------------

.. parsed-literal:: isolated

Use this directive to isolate the current context.
If a key binding can't be found within an isolated context
then it won't be looked up within the default context.

Examples::

   isolated

The Macro Directive
-------------------

.. parsed-literal:: macro *keys* *command* ...

Use this directive to bind a sequence of BRLTY commands to a key combination.

*keys*
   The key combination being defined.

*command* ...
   The BRLTTY commands that are to be executed.

Examples::

   macro Key1+Key2 TOP LNEND

The Map Directive
-----------------

.. parsed-literal:: map *key* *function*

Use this directive to map a key to a braille keyboard function. The mapping is
defined within the current context.

*key*
   The name of the key that is to be mapped. More than one key may be mapped to
   the same braille keyboard function.

.. _The Map Function Operand:

*function*
   The name of the braille keyboard function. It may be one of the following
   keywords:

   ``DOT1``
      The upper-left standard braille dot key.
   ``DOT2``
      The middle-left standard braille dot key.
   ``DOT3``
      The lower-left standard braille dot key.
   ``DOT4``
      The upper-right standard braille dot key.
   ``DOT5``
      The middle-right standard braille dot key.
   ``DOT6``
      The lower-right standard braille dot key.
   ``DOT7``
      The lower-left computer braille dot key.
   ``DOT8``
      The lower-right computer braille dot key.
   ``SPACE``
      The space bar.
   ``SHIFT``
      The shift key.
   ``UPPER``
      If a lowercase letter is being entered then translate it to its
      uppercase equivalent.
   ``CONTROL``
      The control key.
   ``META``
      The left alt (or meta) key.
   ``ALTGR``
      The right alt (or altgr) key.
   ``GUI``
      The gui (or windows) key.

If a key combination consists only of keys which have been mapped to braille 
keyboard functions, and if those functions, when combined, form a valid braille 
keyboard command, then that command is executed as soon as any of the keys is 
released. A valid braille keyboard command must include either any combination 
of dot keys or the space bar (but not both). If at least one dot key is 
included then the braille keyboard functions specified by
`The Superimpose Directive`_ within the same context are also implicitly
included.

Examples::

   map Key1 DOT1

The Note Directive
------------------

.. parsed-literal:: note *text*

Use this directive to add a person-readable explanation to the key table's help
text. Notes are commonly used, for example, to describe the placement, sizes,
and shapes of the keys on the device.

*text*
   The explanation that is to be added. It may contain spaces, and should be
   grammatically correct.

Each note specifies exactly one line of explanatory text. Leading space is 
ignored so indentation cannot be specified.

There's no limit to the number of notes that may be added. All of them are 
gathered together and presented in a single block at the start of the key 
table's help text.

*  A note that doesn't have a special prefix begins a new outer bulleted list
   element.

*  A note that is prefixed with an asterisk (``*``) continues the current outer
   bulleted list element.

*  A note that is prefixed with a plus (``+``) sign is an inner bulletged list
   element.

Examples::

   note This is the first outer list element.
   note This is the second outer list element.
   note * Continue the second outer list element.
   note + The first element of an inner list.
   note + The second element of an inner list.
   note * The third line of the second outer list element.

The above example would be rendered as:

*  This is the first outer list element.

*  This is the second outer list element.
   Continue the second outer list element.

   +  The first element of an inner list.

   +  The second element of an inner list.

   The third line of the second outer list element.

The Run Directive
-----------------

.. parsed-literal:: run *keys* *name* [*argument* ...]

Use this directive to bind a host command to a key combination.

*keys*
   The key combination being defined.

<name*
   The name of the host command. It may also be the path.

*argument* ...
   The arguments to be passed to the host command.

Examples::

   run Key1+Key2 pkill --exact brltty

The Superimpose Directive
-------------------------

.. parsed-literal:: superimpose *function*

Use this directive to implicitly include a braille keyboard function whenever a
braille keyboard command consisting of at least one dot is executed. Only
implicit inclusions defined within the current context are performed. Any
number of these directives may be specified.

*function*
   The name of the braille keyboard function that is to be implicitly included.
   See `The Map Function Operand`_ for details.

Examples::

   superimpose DOT7

The Title Directive
-------------------

.. parsed-literal:: title <text>

Use this directive to specify a person-readable, one-line summary of the key
table's purpose.

*text*
   A brief summary of what the key table is used for. It may contain spaces,
   and standard capitalization conventions should be used.

The title of the key table may be specified only once.

Examples::

   title Bindings for Keypad-based Navigation

.. include:: nesting-directives.rst
.. include:: variable-directives.rst
.. include:: condition-directives.rst

Keyboard Table List
===================

.. csv-table::
   :header-rows: 1
   :file: keyboard-table.csv

Braille Driver List
===================

.. csv-table::
   :header-rows: 1
   :file: braille-driver.csv