This set of commands is mostly about customizing
in terms of keybindings. The most important command is probably
escape, which lets you change the default
prefix escape character.
emacs users, in particular, will want to use
a different prefix, since
C-a is “beginning of line” in
bindkey commands allow you
to add or redefine
screen keybindings. Both can associate arbitrary
screen commands with specific keypresses.
defines keys in
screen's main command class, so the command
bind K kill” would cause the key sequence
C-a K to trigger the
bindkey is more general; it can bind commands to any
keypress, not just ones preceded by
also modify the keypresses used in copy mode.
You can use
C-a ? to see what the current set of
bindkey does is modify one of
screen's three input translation tables. Normally, when you press a
screen checks the user translation table to see if they key is
there; if it is, then the bound action is taken.
changes the user translation table by default, and most arbitrary
keybindings should go there. If the user translation table doesn't have
an entry for the key pressed,
screen then checks the default
translation table; if nothing is there, the keypress gets sent to the
window. The default translation table is used for keybindings that affect
screen's terminal emulation, like the particular escape sequence to
send for a function key.
The third input translation table is for copy mode. You can
use it to change the keys used in that mode. This works a little
differently than the other modes, because there aren't commands for the
things you can do in copy mode. You can, of course, bind any of
screen's normal commands, but if you want to trigger any
copy-mode-specific commands, you have to use
stuff the key sequence for the action you want to take. You can use this
functionality to remap copy mode key bindings, but that's better done with
bindkey is more
useful when you want to chain several actions together.
bindkey updates the user table by default, and the
default and copy mode tables with the
respectively. If you call
bindkey without giving it a
keybinding, it will display the current bindings for the selected mode.
Command classes are how you can implement multi-key bindings in
screen has to do something for every key
the user presses. (Modifiers don't count;
C-a is considered a single
keypress.) To effect a multi-key sequence, you have to tell
that the first keypress activates a command class, where that command
class contains a binding for the next key, and so on. This is effectively
screen keybindings work: the
C-a activates the default
command class, which contains all of the default bindings, plus any that
you've added with
You “activate a command class” with the
Without any arguments, it activates the default command class (just like
C-a does). Its
-c argument activates whatever class is provided
to it. Similarly,
-c option makes a binding
in the specified command class.
(To be fair, command classes are just the most flexible way to implement
multi-key bindings in
will bind commands to strings as well as single characters. If the
characters in the string arrive quickly enough (faster than
maptimeout), they will trigger the binding. The
option will even disable the timeout.)
Sometimes you don't want to activate a keybinding. That's where
mapdefault comes in; it causes the next keypress to not
be checked against the user input translation table (see
bindkey Tables above). This bypassess all
keybindings except the ones needed for its terminal emulation. If you
need to bypass the default input translation table too, use
bind- Binds a command to a key as a standard
bindkey- Binds a command to an arbitrary keypress in any of
screen's input translation tables.
command- Activates a command class.
help- Displays the current keybindings.
mapdefault- Prevents the next keypress from being looked up in the user input translation table.
mapnotnext- Prevents the next keypress from being looked up in any input translation table.
maptimeout- Sets the inter-character timeout for multi-character keybindings.
screen's command prefix character.
meta- Sends the
screencommand prefix character to the current window.
stuff- Sends a string to the current window.
vi users might want to use the escape character as their prefix key.
When doing that, you have to decide whether two escapes in a row will call
other (to switch to the most recently visited window) or
meta (to send an escape character to the window). Here's
an example of each:
# ESC ESC calls meta escape ^[^[ # ESC o calls other bind o other
# ESC [ calls meta escape ^[[ # ESC ESC calls other by default
emacs users will probably want to remap the escape character just
because it interferes with
emacs. One option is to use
C-z instead, as it's close to
screen lets you open new
programs in new windows, rather than having to suspend the current program
The default input translation table is for terminal behavior. To deal with a terminal that wasn't sending the right character for its backspace button, you could use screen to “fix” the keypress:
bindkey -d -k kb stuff "\177"
The copy mode input translation table can be used to automate things in
copy mode. This causes
C-g to find the first occurrence of “foo” in
the buffer and copy the entire line it's on:
bindkey -m ^G stuff "g/foo\012Y"
You can use the default command class to make a second escape key.
Suppose you want both
C-\ to be escape keys. You could do
it like this:
escape ^zz bindkey ^\ command
Let's say you wanted to to make the split commands a little more mnemonic
C-a s h and
C-a s v for “split horizontally” and “split
vertically”, respectively. Here's something that would work:
bind s command -c split_class bind -c split_class h split bind -c split_class v split -v
bind page shows some further examples that use
command classes to make bindings to select windows numbered higher than 9.
It's often useful to have a quote key that sends the next keypress through unintercepted. Here's how to accomplish that:
bind ^Q mapdefault
With that, you can press
C-a C-q another-key and another-key
will be passed through to the window (unless it's affected by the default
input translation table, but you generally want those to still be mapped,
because they affect
screen's terminal definitions).
The keybindings in copy mode are mostly based on
(although it has
emacs-style incremental searching). Here's a
remapping that makes some of the keys closer:
markkeys j=^N:k=^P:l=^F:0=^A:$=^E:^F=^V bindkey -m -t ^[v stuff ^B bindkey -m ^B stuff h bindkey -m -t ^[a stuff \^ bindkey -m -t ^[f stuff w bindkey -m -t ^[b stuff b bindkey -m -t ^[0^[r stuff H # Nothing for 'M' bindkey -m -t ^[-^[r stuff L bindkey -m -t ^[< stuff g bindkey -m -t ^[> stuff G bindkey -m -t ^[d stuff " e "
markkeys is used for the single-character bindings, while
bindkey is used for the multi-character keys. (You can't
specify a meta key, but you can use the combination with escape that is
xterm can even be set up to send an escape character when
a meta-key combination is pressed.)
A more complete mapping is left as an exercise for the reader.
xterm, shift-PgUp and shift-PgDn move through the terminal's
screen keeps a separate scrollback buffer for each
window, so this example lets you use those keypresses to move around
screen's scrollback buffer.
First, you need to disable scrolling in
xterm, so this goes in your
XTerm.vt100.translations: #override \n\ Shift <Key>Prior:string(0x1b) string("[5;2~") \n\ Shift <Key>Next:string(0x1b) string("[6;2~")
Then you need to make shift-PgUp enter copy mode and go back a page, and both key combinations move around in copy mode. This goes in your .screenrc:
bindkey "^[[5;2~" eval "copy" "stuff ^u" bindkey -m "^[[5;2~" stuff ^u bindkey -m "^[[6;2~" stuff ^d