(elisp)Translating Input


Next: Recording Input Prev: Input Modes Up: Terminal Input

Translating Input Events
------------------------

 - Variable: extra-keyboard-modifiers
     This variable lets Lisp programs "press" the modifier keys on the
     keyboard.  The value is a bit mask:

    1
          The SHIFT key.

    2
          The LOCK key.

    4
          The CTL key.

    8
          The META key.

     Each time the user types a keyboard key, it is altered as if the
     modifier keys specified in the bit mask were held down.

     When you use X windows, the program can "press" any of the modifier
     keys in this way.  Otherwise, only the CTL and META keys can be
     virtually pressed.

 - Variable: keyboard-translate-table
     This variable is the translate table for keyboard characters.  It
     lets you reshuffle the keys on the keyboard without changing any
     command bindings.  Its value must be a string or `nil'.

     If `keyboard-translate-table' is a string, then each character read
     from the keyboard is looked up in this string and the character in
     the string is used instead.  If the string is of length N,
     character codes N and up are untranslated.

     In the example below, we set `keyboard-translate-table' to a
     string of 128 characters.  Then we fill it in to swap the
     characters `C-s' and `C-\' and the characters `C-q' and `C-^'.
     Subsequently, typing `C-\' has all the usual effects of typing
     `C-s', and vice versa.  (Note: Flow Control for more information
     on this subject.)

          (defun evade-flow-control ()
            "Replace C-s with C-\ and C-q with C-^."
            (interactive)
            (let ((the-table (make-string 128 0)))
              (let ((i 0))
                (while (< i 128)
                  (aset the-table i i)
                  (setq i (1+ i))))
          
              ;; Swap `C-s' and `C-\'.
              (aset the-table ?\034 ?\^s)
              (aset the-table ?\^s ?\034)
              ;; Swap `C-q' and `C-^'.
              (aset the-table ?\036 ?\^q)
              (aset the-table ?\^q ?\036)
          
              (setq keyboard-translate-table the-table)))

     Note that this translation is the first thing that happens to a
     character after it is read from the terminal.  Record-keeping
     features such as `recent-keys' and dribble files record the
     characters after translation.

 - Function: keyboard-translate FROM TO
     This function modifies `keyboard-translate-table' to translate
     character code FROM into character code TO.  It creates or
     enlarges the translate table if necessary.

 - Variable: function-key-map
     This variable holds a keymap which describes the character
     sequences sent by function keys on an ordinary character terminal.
     This keymap uses the data structure as other keymaps, but is used
     differently: it specifies translations to make while reading
     events.

     If `function-key-map' "binds" a key sequence K to a vector V, then
     when K appears as a subsequence *anywhere* in a key sequence, it
     is replaced with the events in V.

     For example, VT100 terminals send `ESC O P' when the keypad PF1
     key is pressed.  Therefore, we want Emacs to translate that
     sequence of events into the single event `pf1'.  We accomplish
     this by "binding" `ESC O P' to `[pf1]' in `function-key-map', when
     using a VT100.

     Thus, typing `C-c PF1' sends the character sequence `C-c ESC O P';
     later the function `read-key-sequence' translates this back into
     `C-c PF1', which it returns as the vector `[?\C-c pf1]'.

     Entries in `function-key-map' are ignored if they conflict with
     bindings made in the minor mode, local, or global keymaps.  The
     intent is that the character sequences that function keys send
     should not have command bindings in their own right.

     The value of `function-key-map' is usually set up automatically
     according to the terminal's Terminfo or Termcap entry, but
     sometimes those need help from terminal-specific Lisp files.
     Emacs comes with a number of terminal-specific files for many
     common terminals; their main purpose is to make entries in
     `function-key-map' beyond those that can be deduced from Termcap
     and Terminfo.  Note: Terminal-Specific.

     Emacs versions 18 and earlier used totally different means of
     detecting the character sequences that represent function keys.

 - Variable: key-translation-map
     This variable is another keymap used just like `function-key-map'
     to translate input events into other events.  It differs from
     `function-key-map' in two ways:

        * `key-translation-map' goes to work after `function-key-map' is
          finished; it receives the results of translation by
          `function-key-map'.

        * `key-translation-map' overrides actual key bindings.

     The intent of `key-translation-map' is for users to map one
     character set to another, including ordinary characters normally
     bound to `self-insert-command'.


automatically generated by info2www