mirror of
git://git.code.sf.net/p/zsh/code
synced 2025-11-04 07:21:06 +01:00
1405 lines
49 KiB
Text
1405 lines
49 KiB
Text
#compdef tmux
|
|
|
|
# tmux <http://tmux.github.io> completion for zsh <http://zsh.sf.net>.
|
|
#
|
|
# Configuration:
|
|
#
|
|
# - On some OSs, the directory for tmux's server sockets may not be
|
|
# the default (which is /tmp/tmux-<uid>/), but say
|
|
# /var/run/tmux/tmux-<uid>, in which case the completion for
|
|
# 'tmux -L <tab>' will not be able to find the sockets in the default
|
|
# location (debian does this, for instance); tell _tmux the right place
|
|
# to look:
|
|
# % zstyle ':completion:*:*:tmux:*:sockets' socketdir "/var/run/tmux/tmux-${UID}"
|
|
#
|
|
# - tmux knows a *lot* of sub-commands, hence 'tmux <tab>' returns a lot
|
|
# of possible completions. _tmux knows about all commands and their aliases.
|
|
# By default, both are offered. If you do not care about the aliases, do this:
|
|
# % zstyle ':completion:*:*:tmux:*:subcommands' mode 'commands'
|
|
#
|
|
# The same can be done to only return aliases by setting the above style
|
|
# to 'aliases'. The default value is 'both' (but actually every value
|
|
# different from 'commands' and 'aliases' will have the same effect).
|
|
#
|
|
# 'lsw' is an alias for 'list-windows' for example; note that not all
|
|
# commands have aliases. So probably, either the default 'both' or
|
|
# 'commands' makes most sense for this style.
|
|
#
|
|
# - For finer grained control over what is suggested as possible completions,
|
|
# the 'ignored-patterns' style may be used; suppose you think that only
|
|
# '*-window' or '*-windows' are worth being completed. You would get that
|
|
# behaviour like this:
|
|
# % zstyle ':completion:*:*:tmux:*:subcommands' ignored-patterns '^*-window(|s)'
|
|
#
|
|
# Some tmux commands currently do not work if called from a shell prompt,
|
|
# so it would make sense to ignore them per default (at the time of writing,
|
|
# those commands are choose-{session,client,window}, confirm-before and
|
|
# find-window. This would ignore them:
|
|
# % zstyle ':completion:*:*:tmux:*:subcommands' ignored-patterns \
|
|
# 'choose-*' 'confirm-before' 'find-window'
|
|
#
|
|
# The configuration for subcommand completions may be done in
|
|
# this context: ':completion:*:*:tmux-<sub-command>:*:*'
|
|
#
|
|
# TODO:
|
|
#
|
|
# - Implement __tmux-format
|
|
# - Implement __tmux-style (possibly using existing helpers like
|
|
# __tmux-attributes and __tmux-colours)
|
|
# - in _tmux-list-panes, use __tmux-windows or __tmux-sessions
|
|
# depending on -s is among the sub-commands current command line.
|
|
|
|
# Global variables; setup the first time _tmux is called.
|
|
# For $_tmux_commands[] generation, see the very end of this file.
|
|
typeset -ga _tmux_commands=() _tmux_aliases=()
|
|
typeset -gA _tmux_aliasmap
|
|
|
|
_tmux_aliasmap=(
|
|
# clients and sessions
|
|
attach attach-session
|
|
detach detach-client
|
|
has has-session
|
|
lockc lock-client
|
|
locks lock-session
|
|
lsc list-clients
|
|
lscm list-commands
|
|
ls list-sessions
|
|
new new-session
|
|
refresh refresh-client
|
|
rename rename-session
|
|
showmsgs show-messages
|
|
source source-file
|
|
start start-server
|
|
suspendc suspend-client
|
|
switchc switch-client
|
|
|
|
# windows and panes
|
|
breakp break-pane
|
|
capturep capture-pane
|
|
displayp display-panes
|
|
findw find-window
|
|
joinp join-pane
|
|
killp kill-pane
|
|
killw kill-window
|
|
last last-window
|
|
lastp last-pane
|
|
linkw link-window
|
|
lsp list-panes
|
|
lsw list-windows
|
|
movep move-pane
|
|
movew move-window
|
|
neww new-window
|
|
nextl next-layout
|
|
next next-window
|
|
pipep pipe-pane
|
|
prev previous-window
|
|
prevl previous-layout
|
|
renamew rename-window
|
|
resizep resize-pane
|
|
respawnp respawn-pane
|
|
respawnw respawn-window
|
|
rotatew rotate-window
|
|
selectl select-layout
|
|
selectp select-pane
|
|
selectw select-window
|
|
splitw split-window
|
|
swapp swap-pane
|
|
swapw swap-window
|
|
unlinkw unlink-window
|
|
|
|
# key bindings
|
|
bind bind-key
|
|
lsk list-keys
|
|
send send-keys
|
|
unbind unbind-key
|
|
|
|
# options
|
|
set set-option
|
|
setw set-window-option
|
|
show show-options
|
|
showw show-window-options
|
|
|
|
# environment
|
|
setenv set-environment
|
|
showenv show-environment
|
|
|
|
# status line
|
|
confirm confirm-before
|
|
display display-message
|
|
|
|
# buffers
|
|
clearhist clear-history
|
|
deleteb delete-buffer
|
|
lsb list-buffers
|
|
loadb load-buffer
|
|
pasteb paste-buffer
|
|
saveb save-buffer
|
|
setb set-buffer
|
|
showb show-buffer
|
|
|
|
# miscellaneous
|
|
if if-shell
|
|
lock lock-server
|
|
run run-shell
|
|
info server-info
|
|
wait wait-for
|
|
)
|
|
|
|
# --- Sub-command functions ---
|
|
# These *must* be called _tmux-*(); The description generation relies on
|
|
# them being named that way. *No* other functions may match that pattern.
|
|
# Other utility functions should be named __tmux-*() (see below).
|
|
#
|
|
# Another thing, the description generation needs, is handling of
|
|
# $tmux_describe: If that parameter is non-empty, the sub-command function
|
|
# should only print a description of the sub-command it handles and return
|
|
# immidiately after doing so.
|
|
#
|
|
# To add support for a new sub-command, you only have to add a new
|
|
# _tmux-<foo>() function below (preferably alphabetically sorted), that
|
|
# behaves like described above; and add a alias->command pair in the
|
|
# _tmux_aliasmap associative array above (if the comand in fact has an
|
|
# alias). The rest should just work[tm].
|
|
|
|
_tmux-attach-session() {
|
|
[[ -n ${tmux_describe} ]] && print "attach or switch to a session" && return
|
|
|
|
_arguments -s \
|
|
'-c+[specify working directory for the session]:directory:_directories' \
|
|
'-d[detach other clients attached to target session]' \
|
|
'-r[put the client into read-only mode]' \
|
|
'-t+[specify target session]:target session:__tmux-sessions' \
|
|
"-E[don't apply update-environment option]"
|
|
}
|
|
|
|
_tmux-bind-key() {
|
|
[[ -n ${tmux_describe} ]] && print "bind a key to a command" && return
|
|
_arguments -s -A "-*" \
|
|
'-c[bind to command mode instead of normal mode]' \
|
|
'-n[make the binding work without the need for the prefix key]' \
|
|
'-r[the key may repeat]' \
|
|
'-t+[specify mode table for the binding]:mode table:__tmux-mode-tables' \
|
|
'-T+[specify key table for the binding]:key table' \
|
|
'1:key' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-break-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "break a pane from an existing into a new window" && return
|
|
_arguments -s \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-F+[specify output format]:format:__tmux-format__tmux-format' \
|
|
'-P[print information of new window after it has been created]' \
|
|
'-s+[specify source pane]:pane:__tmux-panes' \
|
|
'-t+[specify destination window]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-capture-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "capture the contents of a pane to a buffer" && return
|
|
_arguments -s \
|
|
'-a[use alternate screen]' \
|
|
'-b+[choose target buffer]:target buffer:__tmux-buffers' \
|
|
'-C[escape non-printable characters as octal \\ooo]' \
|
|
'-e[include escape sequences for attributes etc]' \
|
|
'-E[specify last line to capture. - means last line of pane]' \
|
|
'-J[join wrapped lines and preserver trailing space]' \
|
|
'-q[ignore errors when trying to access alternate screen]' \
|
|
'-p[print data to stdout]' \
|
|
'-P[only capture that is the beginning of an as-yet incomplete esc seq]' \
|
|
'-S[specify start line to capture. - means first line of scrollback]' \
|
|
'-t+[choose source pane]:source pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-choose-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "put a window into buffer choice mode" && return
|
|
_arguments -s \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-t+[specify target window]:session:__tmux-windows' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-choose-client() {
|
|
[[ -n ${tmux_describe} ]] && print "put a window into client choice mode" && return
|
|
_arguments -s \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-t+[specify target window]:session:__tmux-windows' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-choose-session() {
|
|
[[ -n ${tmux_describe} ]] && print "put a window into session choice mode" && return
|
|
_arguments -s \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-t+[specify target window]:session:__tmux-windows' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-choose-tree() {
|
|
[[ -n ${tmux_describe} ]] && print "put a window into tree choice mode" && return
|
|
_arguments -s \
|
|
'-b+[override default session command]:session-command' \
|
|
'-c+[override default window command]:window-command' \
|
|
'-S+[specify session format]:session-format:__tmux-formats' \
|
|
'-s[choose among sessions]' \
|
|
'-t+[specify target window]:session:__tmux-windows' \
|
|
'-u[show generated tree uncollapsed at startup]' \
|
|
'-W+[specify window format]:window-format:__tmux-formats' \
|
|
'-w[choose among windows]' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-choose-window() {
|
|
[[ -n ${tmux_describe} ]] && print "put a window into window choice mode" && return
|
|
_arguments -s \
|
|
'-F=[specify output format]:format:__tmux-format' \
|
|
'-t+[specify target window]:session:__tmux-windows' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-clear-history() {
|
|
[[ -n ${tmux_describe} ]] && print "remove and clear history for a pane" && return
|
|
_arguments '-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-clock-mode() {
|
|
[[ -n ${tmux_describe} ]] && print "enter clock mode" && return
|
|
_arguments '-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-command-prompt() {
|
|
[[ -n ${tmux_describe} ]] && print "open the tmux command prompt in a client" && return
|
|
_arguments -s \
|
|
'-I+[specify list of initial inputs]:initial-text (comma-separated list)' \
|
|
'-p+[specify list of prompts]:prompts (comma-separated list)' \
|
|
'-t+[specify target client]:client:__tmux-clients' \
|
|
'*:::template:_tmux'
|
|
}
|
|
|
|
_tmux-confirm-before() {
|
|
[[ -n ${tmux_describe} ]] && print "run a command but ask for confirmation before" && return
|
|
_arguments -s \
|
|
'-p+[specify prompt]:prompt string' \
|
|
'-t+[specify target client]:client:__tmux-clients' \
|
|
'*:::command:_tmux'
|
|
}
|
|
|
|
_tmux-copy-mode() {
|
|
[[ -n ${tmux_describe} ]] && print "enter copy mode" && return
|
|
_arguments -s \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
'-u[scroll up one page]' \
|
|
'-M[begin a mouse drag]'
|
|
}
|
|
|
|
_tmux-delete-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "delete a paste buffer" && return
|
|
_arguments '-b+[specify target buffer name]:buffer:__tmux-buffers'
|
|
}
|
|
|
|
_tmux-detach-client() {
|
|
[[ -n ${tmux_describe} ]] && print "detach a client from the server" && return
|
|
_arguments -s \
|
|
'-a[kill all clients except for the named by -t]' \
|
|
'-P[send SIGHUP to parent process]' \
|
|
'-s+[specify target session and kill its clients]:session:__tmux-sessions' \
|
|
'-t+[specify target client]:client:__tmux-clients'
|
|
}
|
|
|
|
_tmux-display-message() {
|
|
[[ -n ${tmux_describe} ]] && print "display a message in the status line" && return
|
|
_arguments -s -S \
|
|
'-c+[specify target client]:client:__tmux-clients' \
|
|
'-p[print message to stdout]' \
|
|
'-t+[specify target client]:client:__tmux-clients' \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
':message'
|
|
}
|
|
|
|
_tmux-display-panes() {
|
|
[[ -n ${tmux_describe} ]] && print "display an indicator for each visible pane" && return
|
|
_arguments '-t+[specify target client]:client:__tmux-clients'
|
|
}
|
|
|
|
_tmux-find-window() {
|
|
[[ -n ${tmux_describe} ]] && print "search for a pattern in windows" && return
|
|
_arguments -s \
|
|
'-C[match visible contents]' \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-N[match window name]' \
|
|
'-T[match window title]' \
|
|
'-t+[specify target window]:window:__tmux-windows' \
|
|
':window search pattern'
|
|
}
|
|
|
|
_tmux-has-session() {
|
|
[[ -n ${tmux_describe} ]] && print "check and report if a session exists on the server" && return
|
|
_arguments '-t+[specify target session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-if-shell() {
|
|
[[ -n ${tmux_describe} ]] && print "execute a tmux command if a shell-command succeeded" && return
|
|
local curcontext="$curcontext" state line ret=1
|
|
_arguments -C -s \
|
|
'-b[run shell command in background]' \
|
|
"-F[don't execute shell command but use it as a string-value]" \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
'1:shell command:_cmdstring' \
|
|
'2:tmux command (success):->tmuxcmd' \
|
|
'3:tmux command (failure):->tmuxcmd' && ret=0
|
|
if [[ -n $state ]]; then
|
|
compset -q
|
|
_tmux && ret=0
|
|
fi
|
|
}
|
|
|
|
_tmux-join-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "split a pane and move an existing one into the new space" && return
|
|
_arguments -s \
|
|
'-b[join source pane left of or above target pane]' \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-h[split horizontally]' \
|
|
'-v[split vertically]' \
|
|
"-l+[define new pane's size]: :_guard '[0-9]#' 'numeric value'" \
|
|
"-p+[define new pane's size in percent]: :_guard '[0-9]#' 'numeric value'" \
|
|
'-s+[specify source pane]:pane:__tmux-panes' \
|
|
'-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-kill-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "destroy a given pane" && return
|
|
_arguments -s \
|
|
'-a[kill all panes except the one specified by -t]' \
|
|
'-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-kill-server() {
|
|
[[ -n ${tmux_describe} ]] && print "kill clients, sessions and server" && return
|
|
__tmux-nothing-else
|
|
}
|
|
|
|
_tmux-kill-session() {
|
|
[[ -n ${tmux_describe} ]] && print "destroy a given session" && return
|
|
_arguments -s \
|
|
'-a[kill all session except the one specified by -t]' \
|
|
'-t+[specify target session]:session:__tmux-sessions' \
|
|
'-C[clear alerts (bell, activity, silence) in all windows linked to the session]'
|
|
}
|
|
|
|
_tmux-kill-window() {
|
|
[[ -n ${tmux_describe} ]] && print "destroy a given window" && return
|
|
_arguments -s \
|
|
'-a[kill all windows except the one specified by -t]' \
|
|
'-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-last-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "select the previously selected pane" && return
|
|
_arguments -s \
|
|
'-d[disable input to the pane]' \
|
|
'-e[enable input to the pane]' \
|
|
'-t+[specify session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-last-window() {
|
|
[[ -n ${tmux_describe} ]] && print "select the previously selected window" && return
|
|
_arguments '-t+[specify session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-link-window() {
|
|
[[ -n ${tmux_describe} ]] && print "link a window to another" && return
|
|
_arguments -s \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-k[kill the target window if it exists]' \
|
|
'-s+[specify source window]:window:__tmux-windows' \
|
|
'-t+[specify destination window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-list-buffers() {
|
|
[[ -n ${tmux_describe} ]] && print "list paste buffers of a session" && return
|
|
_arguments '-F+[specify output format]:format:__tmux-format'
|
|
}
|
|
|
|
_tmux-list-clients() {
|
|
[[ -n ${tmux_describe} ]] && print "list clients attached to server" && return
|
|
_arguments -s \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-t+[specify session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-list-commands() {
|
|
[[ -n ${tmux_describe} ]] && print "list supported sub-commands" && return
|
|
__tmux-nothing-else
|
|
}
|
|
|
|
_tmux-list-keys() {
|
|
[[ -n ${tmux_describe} ]] && print "list all key-bindings" && return
|
|
_arguments -s \
|
|
'-t+[specify mode table]:mode table:__tmux-mode-tables' \
|
|
'-T+[specify key table]:key table'
|
|
}
|
|
|
|
_tmux-list-panes() {
|
|
[[ -n ${tmux_describe} ]] && print "list panes of a window" && return
|
|
local -a args
|
|
if (( ${+words[(r)-*s*]} )); then
|
|
args=( '-t+[specify target session]:session:__tmux-sessions' )
|
|
else
|
|
args=( '-t+[specify target window]:window:__tmux-windows' )
|
|
fi
|
|
_arguments -s $args \
|
|
'-a[list all panes the server possesses]' \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-s[if specified, -t chooses a session]'
|
|
}
|
|
|
|
_tmux-list-sessions() {
|
|
[[ -n ${tmux_describe} ]] && print "list sessions managed by server" && return
|
|
_arguments '-F+[specify output format]:format:__tmux-format'
|
|
}
|
|
|
|
_tmux-list-windows() {
|
|
[[ -n ${tmux_describe} ]] && print "list windows of a session" && return
|
|
_arguments -s \
|
|
'-a[list all windows the tmux server possesses]' \
|
|
'-F[specify output format]:format:__tmux-format' \
|
|
'-t+[specify session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-load-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "load a file into a paste buffer" && return
|
|
_arguments -A "-*" -S \
|
|
'-b+[specify target buffer name]:buffer:__tmux-buffers' \
|
|
'1:file:_files'
|
|
}
|
|
|
|
_tmux-lock-client() {
|
|
[[ -n ${tmux_describe} ]] && print "lock a client" && return
|
|
_arguments '-t+[specify client]:client:__tmux-clients'
|
|
}
|
|
|
|
_tmux-lock-server() {
|
|
[[ -n ${tmux_describe} ]] && print "lock all clients attached to the server" && return
|
|
__tmux-nothing-else
|
|
}
|
|
|
|
_tmux-lock-session() {
|
|
[[ -n ${tmux_describe} ]] && print "lock all clients attached to a session" && return
|
|
_arguments '-t+[specify session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-move-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "move a pane into a new space" && return
|
|
_arguments -s \
|
|
'-b[join source pane left of or above target pane]' \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-h[split horizontally]' \
|
|
'-v[split vertically]' \
|
|
"-l+[define new pane's size]:numeric value" \
|
|
"-p+[define new pane's size in percent]:numeric value" \
|
|
'-s+[specify source pane]:pane:__tmux-panes' \
|
|
'-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-move-window() {
|
|
[[ -n ${tmux_describe} ]] && print "move a window to another" && return
|
|
_arguments -s \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-k[kill the target window if it exists]' \
|
|
'-s+[specify source window]:window:__tmux-windows' \
|
|
'-r[renumber windows in session in sequential order]' \
|
|
'-t+[specify destination window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-new-session() {
|
|
[[ -n ${tmux_describe} ]] && print "create a new session" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-A[attach to existing session if it already exists]' \
|
|
'-c+[specify working directory for the session]:directory:_directories' \
|
|
"-d[don't attach new session to current terminal]" \
|
|
"-D[in case of -A behave like attach-session's -d]" \
|
|
"-E[don't apply update-environment option]" \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-n+[specify initial window name]:window name' \
|
|
'-P[print information about new session after it is created]' \
|
|
'-s+[name the session]:session name:__tmux-sessions' \
|
|
'-t+[specify target session]:session:__tmux-sessions' \
|
|
'-x[specify width]:width' \
|
|
'-y[specify height]:height' \
|
|
'*:: :_cmdstring'
|
|
}
|
|
|
|
_tmux-new-window() {
|
|
[[ -n ${tmux_describe} ]] && print "create a new window" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-a[insert new window at next free index from -t]' \
|
|
'-c+[specify working directory for the session]:directory:_directories' \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-k[destroy it if the specified window exists]' \
|
|
'-n+[specify a window name]:window name' \
|
|
'-P[print information about new window after it is created]' \
|
|
'-t+[specify target window]:window:__tmux-windows' \
|
|
'*:: :_cmdstring'
|
|
}
|
|
|
|
_tmux-next-layout() {
|
|
[[ -n ${tmux_describe} ]] && print "move a window to the next layout" && return
|
|
_arguments '-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-next-window() {
|
|
[[ -n ${tmux_describe} ]] && print "move to the next window in a session" && return
|
|
_arguments -s \
|
|
'-a[move to the next window with an alert]' \
|
|
'-t+[specify target session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-paste-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "insert a paste buffer into the window" && return
|
|
_arguments -s \
|
|
'-b+[specify buffer]:source buffer:__tmux-buffers' \
|
|
'-d[remove buffer from stack after pasting]' \
|
|
'-p[use bracketed paste mode if the application requested it]' \
|
|
"-r[don't replace LF with CR when pasting]" \
|
|
'-s+[specify separator]:separator' \
|
|
'-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-pipe-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "pipe output from a pane to a shell command" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-o[only open a pipe if none is currently opened]' \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
':shell command:_cmdstring'
|
|
}
|
|
|
|
_tmux-previous-layout() {
|
|
[[ -n ${tmux_describe} ]] && print "move a window to the previous layout" && return
|
|
_arguments '-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-previous-window() {
|
|
[[ -n ${tmux_describe} ]] && print "move to the previous window in a session" && return
|
|
_arguments -s \
|
|
'-a[move to the previous window with an alert]' \
|
|
'-t+[specify target session]:session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-refresh-client() {
|
|
[[ -n ${tmux_describe} ]] && print "refresh a client" && return
|
|
_arguments -s \
|
|
"-S[only update the client's status bar]" \
|
|
'-t+[specify target client]:client:__tmux-clients' \
|
|
'-C+:size'
|
|
}
|
|
|
|
_tmux-rename-session() {
|
|
[[ -n ${tmux_describe} ]] && print "rename a session" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-t+[specify target session]:session:__tmux-sessions' \
|
|
':new session name'
|
|
}
|
|
|
|
_tmux-rename-window() {
|
|
[[ -n ${tmux_describe} ]] && print "rename a window" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-t+[specify target window]:window:__tmux-windows' \
|
|
':new window name'
|
|
}
|
|
|
|
_tmux-resize-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "resize a pane" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-D[resize downward]' \
|
|
'-L[resize to the left]' \
|
|
'-M[begin mouse resizing]' \
|
|
'-R[resize to the right]' \
|
|
'-U[resize upward]' \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
'-x+[specify width]:width' \
|
|
'-y+[specify height]:height' \
|
|
'-Z[toggle zoom of pane]' \
|
|
':adjustment'
|
|
}
|
|
|
|
_tmux-respawn-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "reuse a pane in which a command has exited" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-k[kill window if it is in use]' \
|
|
'-t+[specify target pane]:pane:__tmux-pane' \
|
|
':command:_cmdstring'
|
|
}
|
|
|
|
_tmux-respawn-window() {
|
|
[[ -n ${tmux_describe} ]] && print "reuse a window in which a command has exited" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-k[kill window if it is in use]' \
|
|
'-t+[specify target window]:window:__tmux-windows' \
|
|
':command:_cmdstring'
|
|
}
|
|
|
|
_tmux-rotate-window() {
|
|
[[ -n ${tmux_describe} ]] && print "rotate positions of panes in a window" && return
|
|
_arguments -s \
|
|
'-D[rotate downward]' \
|
|
'-U[rotate upward]' \
|
|
'-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-run-shell() {
|
|
[[ -n ${tmux_describe} ]] && print "execute a command without creating a new window" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-b[run shell command in background]' \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
':command:_cmdstring'
|
|
}
|
|
|
|
_tmux-save-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "save a paste buffer to a file" && return
|
|
_arguments -s \
|
|
'-a[append to rather than overwriting file]' \
|
|
'-b+[specify a target buffer index]:buffer:__tmux-buffers'
|
|
}
|
|
|
|
_tmux-select-layout() {
|
|
[[ -n ${tmux_describe} ]] && print "choose a layout for a window" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-n[behave like next-layout]' \
|
|
'-o[revert to previous layout]' \
|
|
'-p[behave like previous-layout]' \
|
|
'-t+[specify a target window]:target window:__tmux-windows' \
|
|
':layout:(even-horizontal even-vertical main-horizontal main-vertical)'
|
|
}
|
|
|
|
_tmux-select-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "make a pane the active one in the window" && return
|
|
_arguments -s \
|
|
'-D[move to the pane below target]' \
|
|
'-d[disable input to the pane]' \
|
|
'-e[enable input to the pane]' \
|
|
'-g[show current pane style]' \
|
|
'-l[behave like last-pane]' \
|
|
'-L[move to the pane left of target]' \
|
|
'-M[clear marked pane]' \
|
|
'-m[set marked pane]' \
|
|
'-R[move to the pane right of target]' \
|
|
'-U[move to the pane above target]' \
|
|
'-P+[set pane style]:style:__tmux-style' \
|
|
'-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-select-window() {
|
|
[[ -n ${tmux_describe} ]] && print "select a window" && return
|
|
_arguments -s \
|
|
'-l[behave like last-window]' \
|
|
'-n[behave like next-window]' \
|
|
'-p[behave like previous-window]' \
|
|
'-T[if selected window is the current behave like last-window]' \
|
|
'-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-send-keys() {
|
|
[[ -n ${tmux_describe} ]] && print "send key(s) to a window" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-l[disable key name lookup and send data literally]' \
|
|
'-R[reset terminal state]' \
|
|
'-M[pass through a mouse event]' \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
'*:key'
|
|
}
|
|
|
|
_tmux-send-prefix() {
|
|
[[ -n ${tmux_describe} ]] && print "send the prefix key to a window" && return
|
|
_arguments -s \
|
|
'-2[send secondary prefix key]' \
|
|
'-t+[specify target pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-server-info() {
|
|
[[ -n ${tmux_describe} ]] && print "show server information" && return
|
|
__tmux-nothing-else
|
|
}
|
|
|
|
_tmux-set-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "set contents of a paster buffer" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-a[append to rather than overwriting target buffer]' \
|
|
'-b+[specify target buffer index]:pane:__tmux-buffers' \
|
|
'-n+[specify new buffer name]:buffer-name' \
|
|
':data'
|
|
}
|
|
|
|
_tmux-set-environment() {
|
|
[[ -n ${tmux_describe} ]] && print "(un)set an environment variable" && return
|
|
_arguments -s -A "-*" -S \
|
|
'-g[modify global environment]' \
|
|
'-r[remove variable before starting new processes]' \
|
|
'-u[unset a variable]' \
|
|
'-t[specify target session]:target session:__tmux-sessions' \
|
|
':name' ':value'
|
|
}
|
|
|
|
_tmux-set-option() {
|
|
[[ -n ${tmux_describe} ]] && print "set a session option" && return
|
|
local mode=session
|
|
local curcontext="$curcontext" state line ret=1
|
|
typeset -A opt_args
|
|
_arguments -C -s \
|
|
'-a[append to string options]' \
|
|
'-g[set a global session option]' \
|
|
'-o[prevent setting of an option that is already set]' \
|
|
'-q[suppress errors about unknown or ambiguous options]' \
|
|
'-u[unset a non-global option]' \
|
|
'-w[change window (not session) options]' \
|
|
'-s[change server (not session) options]' \
|
|
'-t+[specify target session]:target session:__tmux-sessions' \
|
|
'*:: :->name_or_value' && ret=0
|
|
|
|
if (( ${+opt_args[-w]} )); then
|
|
mode=window
|
|
elif (( ${+opt_args[-s]} )); then
|
|
mode=server
|
|
fi
|
|
__tmux-options-complete ${mode} ${state} && ret=0
|
|
return ret
|
|
}
|
|
|
|
_tmux-set-window-option() {
|
|
[[ -n ${tmux_describe} ]] && print "set a window option" && return
|
|
local curcontext="$curcontext" state line ret=1
|
|
typeset -A opt_args
|
|
_arguments -C -s \
|
|
'-a[append to string options]' \
|
|
'-g[set a global window option]' \
|
|
'-o[prevent setting of an option that is already set]' \
|
|
'-q[suppress errors about unknown or ambiguous options]' \
|
|
'-u[unset a non-global option]' \
|
|
'-t+[specify target window]:target window:__tmux-windows' \
|
|
'*:: :->name_or_value' && ret=0
|
|
__tmux-options-complete window ${state} && ret=0
|
|
return ret
|
|
}
|
|
|
|
_tmux-set-hook() {
|
|
[[ -n ${tmux_describe} ]] && print "set a hook to a command" && return
|
|
_arguments -s \
|
|
'-g[add hook to global list]' \
|
|
'-t+[specify target session]:session:__tmux-sessions'
|
|
':command'
|
|
}
|
|
|
|
_tmux-show-hooks() {
|
|
[[ -n ${tmux_describe} ]] && print "show the global list of hooks" && return
|
|
_arguments -s -S -A "-*" \
|
|
'-g[show global list of hooks]' \
|
|
'-t+[specify target session]:session:__tmux-sessions' \
|
|
':hook name:(alert-activity alert-bell alert-silence client-attached client-detached client-resized pane-died pane-exited)' \
|
|
}
|
|
|
|
_tmux-show-buffer() {
|
|
[[ -n ${tmux_describe} ]] && print "display the contents of a paste buffer" && return
|
|
_arguments '-b[specify target buffer index]:pane:->buffer'
|
|
}
|
|
|
|
_tmux-show-environment() {
|
|
[[ -n ${tmux_describe} ]] && print "display the environment" && return
|
|
_arguments -s \
|
|
'-g[show global environment]' \
|
|
'-s[format output as Bourne shell commands]' \
|
|
'-t+[specify target session]:target session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-show-messages() {
|
|
[[ -n ${tmux_describe} ]] && print "show client's message log" && return
|
|
_arguments -s \
|
|
'-J[show debugging information about running jobs]' \
|
|
'-T[show debugging information about involved terminals]' \
|
|
'-t+[specify target client]:client:__tmux-clients'
|
|
}
|
|
|
|
_tmux-show-options() {
|
|
[[ -n ${tmux_describe} ]] && print "show session options" && return
|
|
_arguments -s \
|
|
'-g[show global options]' \
|
|
'-q[suppress errors about unknown or ambiguous options]' \
|
|
'-s[show server options]' \
|
|
'-v[show only the option value, not the name]' \
|
|
'-w[show window options]' \
|
|
'-t+[specify target session]:target session:__tmux-sessions'
|
|
}
|
|
|
|
_tmux-show-window-options() {
|
|
[[ -n ${tmux_describe} ]] && print "show window options" && return
|
|
_arguments -s \
|
|
'-g[show global options]' \
|
|
'-v[show only the option value, not the name]' \
|
|
'-t+[specify target window]:target window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-source-file() {
|
|
[[ -n ${tmux_describe} ]] && print "execute tmux commands from a file" && return
|
|
_files
|
|
}
|
|
|
|
_tmux-split-window() {
|
|
[[ -n ${tmux_describe} ]] && print "splits a pane into two" && return
|
|
_arguments -s \
|
|
'-b[create new pane left of or above target pane]' \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-F+[specify output format]:format:__tmux-format' \
|
|
'-h[split horizontally]' \
|
|
'-v[split vertically]' \
|
|
"-l[define new pane's size]:size" \
|
|
"-p[define new pane's size in percent]:size (percentage)" \
|
|
'-t+[specify target pane]:pane:__tmux-panes' \
|
|
':command:_cmdstring'
|
|
# Yes, __tmux-panes is correct here. The behaviour was changed
|
|
# in recent tmux versions and makes more sense. Except that
|
|
# changing the command's name might annoy users. So it stays like
|
|
# this.
|
|
}
|
|
|
|
_tmux-start-server() {
|
|
[[ -n ${tmux_describe} ]] && print "start a tmux server" && return
|
|
__tmux-nothing-else
|
|
}
|
|
|
|
_tmux-suspend-client() {
|
|
[[ -n ${tmux_describe} ]] && print "suspend a client" && return
|
|
_arguments '-t+[specify destination client]:client:__tmux-clients'
|
|
}
|
|
|
|
_tmux-swap-pane() {
|
|
[[ -n ${tmux_describe} ]] && print "swap two panes" && return
|
|
_arguments -s \
|
|
'-D[move pane down]' \
|
|
'-U[move pane up]' \
|
|
"-d[don't change the active pane]" \
|
|
'-s+[specify source pane]:pane:__tmux-panes' \
|
|
'-t+[specify destination pane]:pane:__tmux-panes'
|
|
}
|
|
|
|
_tmux-swap-window() {
|
|
[[ -n ${tmux_describe} ]] && print "swap two windows" && return
|
|
_arguments -s \
|
|
"-d[don't make the new window become the active one]" \
|
|
'-s+[specify source window]:window:__tmux-windows' \
|
|
'-t+[specify destination window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-switch-client() {
|
|
[[ -n ${tmux_describe} ]] && print "switch the client to another session" && return
|
|
_arguments -s \
|
|
'-c+[specify a target client]:client:__tmux-clients' \
|
|
"-E[don't apply update-environment option]" \
|
|
'-l[move client to last session]' \
|
|
'-n[move client to next session]' \
|
|
'-p[move client to previous session]' \
|
|
'-r[toggle read-only flag of client]' \
|
|
'-t+[specify target window]:window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-unbind-key() {
|
|
[[ -n ${tmux_describe} ]] && print "unbind a key" && return
|
|
local curcontext="$curcontext" state line keytable
|
|
local -a ow
|
|
|
|
ow=( "${words[@]}" )
|
|
_arguments -C -s \
|
|
'-a[remove all key bindings]' \
|
|
'-c[kill the window if it is only in one session]' \
|
|
'-n[remove a non-prefix binding]' \
|
|
'-t+[specify mode table]:mode table:__tmux-mode-tables' \
|
|
'-T[specify key table]:key table' \
|
|
'*:: :->boundkeys'
|
|
|
|
[[ ${state} != 'boundkeys' ]] && return
|
|
keytable="$(__tmux-get-optarg -t "${ow[@]}")"
|
|
if [[ -n ${keytable} ]]; then
|
|
__tmux-bound-keys -t ${keytable}
|
|
return
|
|
fi
|
|
__tmux-bound-keys
|
|
}
|
|
|
|
_tmux-unlink-window() {
|
|
[[ -n ${tmux_describe} ]] && print "unlink a window" && return
|
|
_arguments -s \
|
|
'-k[kill the window if it is only in one session]' \
|
|
'-t+[specify target window]:target window:__tmux-windows'
|
|
}
|
|
|
|
_tmux-wait-for() {
|
|
[[ -n ${tmux_describe} ]] && print "wait for an event or trigger it" && return
|
|
_arguments -s \
|
|
'-L[lock the named channel]' \
|
|
'-S[send signal to channel]' \
|
|
'-U[unlock the named channel]' \
|
|
':event channel'
|
|
}
|
|
|
|
# --- Utility functions ---
|
|
# They should be called __tmux-*() and kept seperate from the
|
|
# sub-command functions.
|
|
|
|
function __tmux-attributes() {
|
|
local -a attr already
|
|
attr=( default bright bold dim underscore blink reverse hidden italics )
|
|
compset -P '*,'
|
|
already=( ${(s<,>)IPREFIX} )
|
|
_describe -t tmux-attribute 'tmux attribute' attr -S, -F already -q
|
|
}
|
|
|
|
function __tmux-buffers() {
|
|
local expl
|
|
local -a buffers
|
|
|
|
if [[ ${(t)bopts} != *array* ]]; then
|
|
local -a bopts; bopts=()
|
|
fi
|
|
|
|
buffers=( ${${(f)"$(command tmux 2> /dev/null list-buffers "${bopts[@]}")"}/:[ $'\t']##/:} )
|
|
_describe -t buffers 'buffers' buffers
|
|
}
|
|
|
|
function __tmux-bound-keys() {
|
|
local expl
|
|
local -a keys
|
|
|
|
keys=( ${${${${(f)"$(command tmux 2> /dev/null list-keys "$@")"}/:[ $'\t']##/:}/(#s)[ $'\t']##/}/(#s):/\\:} )
|
|
_describe -t keys 'keys' keys
|
|
}
|
|
|
|
function __tmux-clients() {
|
|
local expl
|
|
local -a clients
|
|
clients=( ${${(f)"$(command tmux 2> /dev/null list-clients)"}/:[ $'\t']##/:} )
|
|
_describe -t clients 'clients' clients
|
|
}
|
|
|
|
function __tmux-format() {
|
|
_message 'not implemented yet'
|
|
}
|
|
|
|
function __tmux-colours() {
|
|
local -a colnames
|
|
colnames=( default black red green yellow blue magenta cyan white colourN:"replace N by a number between 0 and 255" )
|
|
compset -P 'colour*'
|
|
if [[ -z ${IPREFIX} ]]; then
|
|
_describe -t tmux-colours 'colour' colnames
|
|
else
|
|
_message 'colour number 0..255'
|
|
fi
|
|
}
|
|
|
|
function __tmux-get-optarg() {
|
|
local opt="$1"
|
|
local -i i
|
|
shift
|
|
|
|
for (( i = 1; i <= $#; i++ )); do
|
|
if [[ ${argv[$i]} == ${opt} ]]; then
|
|
if [[ ${argv[$(( i + 1 ))]} != -* ]]; then
|
|
print -- ${argv[$(( i + 1 ))]}
|
|
fi
|
|
return
|
|
fi
|
|
done
|
|
}
|
|
|
|
__tmux-mode-tables() {
|
|
local expl
|
|
_description mode-tables expl 'mode table'
|
|
compadd "$@" "$expl[@]" vi-edit emacs-edit vi-choice emacs-choice vi-copy emacs-copy
|
|
}
|
|
|
|
__tmux-nothing-else() {
|
|
_message "no further arguments"
|
|
}
|
|
|
|
function __tmux-option-guard() {
|
|
local mode opt guard int_guard
|
|
mode="$1"
|
|
opt="$2"
|
|
shift; shift
|
|
local -a options desc
|
|
int_guard='_guard "[0-9]#" "'${opt}': numeric value"'
|
|
if [[ ${mode} == 'session' ]]; then
|
|
options=(
|
|
'assume-paste-time:'${int_guard}
|
|
'base-index:'${int_guard}
|
|
'bell-action:DESC:any none current other'
|
|
'bell-on-alert:DESC:on off'
|
|
'default-command:MSG:command string'
|
|
'default-shell:MSG:shell executable'
|
|
'destroy-unattached:DESC:on off'
|
|
'detach-on-destroy:DESC:on off'
|
|
'display-panes-colour:__tmux-colours'
|
|
'display-panes-active-colour:__tmux-colours'
|
|
'display-panes-time:'${int_guard}
|
|
'display-time:'${int_guard}
|
|
'history-limit:'${int_guard}
|
|
'lock-after-time:'${int_guard}
|
|
'lock-command:MSG:command string'
|
|
'message-command-style:__tmux-style'
|
|
'message-style:__tmux-style'
|
|
'mouse:DESC:on off'
|
|
'mouse-utf8:DESC:on off'
|
|
'prefix:MSG:primary prefix key'
|
|
'prefix2:MSG:secondary prefix key'
|
|
'renumber-windows:DESC:on off'
|
|
'repeat-time:'${int_guard}
|
|
'set-remain-on-exit:DESC:on off'
|
|
'set-titles:DESC:on off'
|
|
'set-titles-string:MSG:title format string'
|
|
'status:DESC:on off'
|
|
'status-interval:'${int_guard}
|
|
'status-justify:DESC:left centre right'
|
|
'status-keys:DESC:vi emacs'
|
|
'status-left:MSG:format string'
|
|
'status-left-length:'${int_guard}
|
|
'status-left-style:__tmux-style'
|
|
'status-position:DESC:top bottom'
|
|
'status-right:MSG:format string'
|
|
'status-right-length:'${int_guard}
|
|
'status-right-style:__tmux-style'
|
|
'status-style:__tmux-style'
|
|
'status-utf8:DESC:on off'
|
|
'update-environment:MSG:string listing env. variables'
|
|
'visual-activity:DESC:on off'
|
|
'visual-bell:DESC:on off'
|
|
'visual-silence:DESC:on off'
|
|
'word-separators:MSG:separator string'
|
|
)
|
|
elif [[ ${mode} == 'server' ]]; then
|
|
options=(
|
|
'buffer-limit:'${int_guard}
|
|
'default-terminal:MSG:terminal string'
|
|
'escape-time:'${int_guard}
|
|
'exit-unattached:DESC:on off'
|
|
'focus-events:DESC:on off'
|
|
'history-file:_path-files -g "*(-.)"'
|
|
'message-limit:'${int_guard}
|
|
'quiet:DESC:on off'
|
|
'set-clipboard:DESC:on off'
|
|
'terminal-overrides:MSG:overrides string'
|
|
)
|
|
else
|
|
options=(
|
|
'aggressive-resize:DESC:on off'
|
|
'allow-rename:DESC:on off'
|
|
'alternate-screen:DESC:on off'
|
|
'automatic-rename:DESC:on off'
|
|
'automatic-rename-format:DESC:__tmux-format'
|
|
'clock-mode-colour:__tmux-colours'
|
|
'clock-mode-style:DESC:12 24'
|
|
'force-height:'${int_guard}
|
|
'force-width:'${int_guard}
|
|
'main-pane-height:'${int_guard}
|
|
'main-pane-width:'${int_guard}
|
|
'mode-keys:DESC:vi emacs'
|
|
'mode-style:__tmux-style'
|
|
'monitor-activity:DESC:on off'
|
|
'monitor-silence:DESC:on off'
|
|
'other-pane-height:'${int_guard}
|
|
'other-pane-width:'${int_guard}
|
|
'pane-active-border-style:__tmux-style'
|
|
'pane-base-index:'${int_guard}
|
|
'pane-border-style:__tmux-style'
|
|
'remain-on-exit:DESC:on off'
|
|
'synchronize-panes:DESC:on off'
|
|
'utf8:DESC:on off'
|
|
'window-active-style:__tmux-style'
|
|
'window-status-activity-style:__tmux-style'
|
|
'window-status-bell-style:__tmux-style'
|
|
'window-status-current-format:MSG:status format string'
|
|
'window-status-current-style:__tmux-style'
|
|
'window-status-format:MSG:status format string'
|
|
'window-status-last-style:__tmux-style'
|
|
'window-status-separator:MSG:separator string'
|
|
'window-status-style:__tmux-style'
|
|
'window-style:__tmux-style'
|
|
'wrap-seach:DESC:on off'
|
|
'xterm-keys:DESC:on off'
|
|
)
|
|
fi
|
|
|
|
guard=${(M)options:#$opt:*}
|
|
if [[ -z ${guard} ]]; then
|
|
_message "unknown ${mode} option: ${opt}"
|
|
return
|
|
fi
|
|
_message "${mode} option value"
|
|
guard=${guard#*:}
|
|
case ${guard} in
|
|
('') ;;
|
|
(MSG:*)
|
|
_message ${guard#*:}
|
|
;;
|
|
(DESC:*)
|
|
eval "desc=( ${guard#*:} )"
|
|
_describe -t "tmux-${mode}-option-value" "${opt}" desc
|
|
;;
|
|
(*)
|
|
eval ${guard}
|
|
;;
|
|
esac
|
|
}
|
|
|
|
function __tmux-session-options() {
|
|
local -a tmux_session_options
|
|
tmux_session_options=(
|
|
'assume-paste-time:assume keys are pasted instead of typed if this fast'
|
|
'base-index:define where to start numbering'
|
|
'bell-action:set action on window bell'
|
|
'bell-on-alert:ring the terminal bell when an alert occurs'
|
|
'default-command:default command for new windows'
|
|
'default-shell:default shell executable'
|
|
'destroy-unattached:destroy session if no client is attached'
|
|
'detach-on-destroy:detach client if attached session is destroyed'
|
|
'display-panes-colour:colour used for display-panes'
|
|
'display-panes-active-colour:colour for active pane in display-panes'
|
|
'display-panes-time:time (in msecs) of display-panes output'
|
|
'display-time:time (in msecs) messages are displayed'
|
|
'history-limit:number of copy-mode lines per window'
|
|
'lock-after-time:lock sessions after N seconds'
|
|
'lock-command:command to run for locking a client'
|
|
'message-command-style:status line message command style'
|
|
'message-style:status line message style'
|
|
'mouse:enable mouse support'
|
|
'mouse-utf8:request utf8 mouse support'
|
|
'prefix:primary prefix key'
|
|
'prefix2:secondary prefix key'
|
|
'renumber-windows:renumber windows if a window is closed'
|
|
'repeat-time:time for multiple commands without prefix-key presses'
|
|
'set-remain-on-exit:set remain-on-exit window option'
|
|
'set-titles:try to set xterm window titles'
|
|
'set-titles-string:format used by set-titles'
|
|
'status:show or hide the status bar'
|
|
'status-interval:interval (in seconds) for status bar updates'
|
|
'status-justify:position of the window list in status bar'
|
|
'status-keys:mode to use in status bar modes (vi/emacs)'
|
|
'status-left:format to use left in status bar'
|
|
'status-left-length:maximum length of the left part of the status bar'
|
|
'status-left-style:style of left part of status line'
|
|
'status-position:status line position'
|
|
'status-right:format to use right in status bar'
|
|
'status-right-length:maximum length of the right part of the status bar'
|
|
'status-right-style:style of right part of status line'
|
|
'status-style:style status line'
|
|
'status-utf8:assume UTF-8 sequences to appear in status bar'
|
|
"update-environment:list of variables to be copied to a session's environment"
|
|
'visual-activity:display status line messages upon activity'
|
|
'visual-bell:use visual bell instead of audible'
|
|
'visual-silence:print a message if monitor-silence is on'
|
|
'word-separators:string of characters considered word separators'
|
|
)
|
|
_describe -t tmux-options 'tmux session option' tmux_session_options
|
|
}
|
|
|
|
function __tmux-options-complete() {
|
|
local mode="$1" state="$2"
|
|
|
|
case ${state} in
|
|
name_or_value)
|
|
if (( CURRENT == 1 )) && [[ ${mode} == 'session' ]]; then
|
|
__tmux-session-options
|
|
elif (( CURRENT == 1 )) && [[ ${mode} == 'server' ]]; then
|
|
__tmux-server-options
|
|
elif (( CURRENT == 1 )) && [[ ${mode} == 'window' ]]; then
|
|
__tmux-window-options
|
|
elif (( CURRENT == 2 )); then
|
|
__tmux-option-guard ${mode} ${words[1]}
|
|
else
|
|
__tmux-nothing-else
|
|
fi
|
|
;;
|
|
esac
|
|
}
|
|
|
|
function __tmux-panes() {
|
|
local expl line
|
|
local -i num
|
|
local -a panes opts
|
|
|
|
compset -P '*.'
|
|
if [[ -n ${IPREFIX} ]]; then
|
|
opts=( -t "${IPREFIX%.}" )
|
|
else
|
|
opts=( )
|
|
fi
|
|
num=0
|
|
command tmux 2> /dev/null list-panes "${opts[@]}" | while IFS= read -r line; do
|
|
panes+=( $(( num++ )):${line//:/} )
|
|
done
|
|
_describe -t panes 'panes' panes "$@"
|
|
if [[ ${IPREFIX} != *. ]]; then
|
|
_wanted windows expl 'windows' __tmux-windows -S.
|
|
fi
|
|
}
|
|
|
|
function __tmux-server-options() {
|
|
local -a tmux_server_options
|
|
tmux_server_options=(
|
|
'buffer-limit:number of buffers kept per session'
|
|
'default-terminal:default terminal definition string'
|
|
'escape-time:set timeout to detect single escape characters (in msecs)'
|
|
'exit-unattached:make server exit if it has no attached clients'
|
|
'focus-events:request focus events from terminal'
|
|
'history-file:tmux command history file name'
|
|
'message-limit:set size of message log per client'
|
|
'quiet:enable/disable the display of various informational messages'
|
|
'set-clipboard:use esc sequences to set terminal clipboard'
|
|
'terminal-overrides:override terminal descriptions'
|
|
)
|
|
_describe -t tmux-server-options 'tmux server option' tmux_server_options
|
|
}
|
|
|
|
function __tmux-sessions() {
|
|
local -a sessions
|
|
sessions=( ${${(f)"$(command tmux 2> /dev/null list-sessions)"}/:[ $'\t']##/:} )
|
|
_describe -t sessions 'sessions' sessions "$@"
|
|
}
|
|
|
|
function __tmux-socket-name() {
|
|
local expl sdir
|
|
local curcontext="${curcontext}"
|
|
local -a socks
|
|
zstyle -s ":completion:${curcontext}:sockets" socketdir sdir || sdir="${TMUX_TMPDIR:-/tmp}/tmux-${UID}"
|
|
socks=(${sdir}/*(=:t))
|
|
_wanted socket expl 'socket name' compadd ${expl} -- ${socks}
|
|
}
|
|
|
|
function __tmux-style() {
|
|
_message 'not implemented yet'
|
|
}
|
|
|
|
function __tmux-window-options() {
|
|
local -a tmux_window_options
|
|
tmux_window_options=(
|
|
'aggressive-resize:aggressively resize windows'
|
|
'allow-rename:allow programs to change window titles'
|
|
'alternate-screen:allow alternate screen feature to be used'
|
|
'automatic-rename:attempt to automatically rename windows'
|
|
'automatic-rename-format:format for automatic renames'
|
|
'clock-mode-colour:set clock colour'
|
|
'clock-mode-style:set clock hour format (12/24)'
|
|
'force-height:force a windows to a certain height'
|
|
'force-width:force a windows to a certain width'
|
|
'main-pane-height:set height for main-* layouts'
|
|
'main-pane-width:set width for main-* layouts'
|
|
'mode-keys:mode to use in copy and choice modes (vi/emacs)'
|
|
'mode-style:set window modes style'
|
|
'monitor-activity:monitor window activity'
|
|
'monitor-silence:monitor window for inactivity'
|
|
'other-pane-height:height of other panes'
|
|
'other-pane-width:width of other panes'
|
|
'pane-active-border-style:style of border of active pane'
|
|
'pane-base-index:integer at which to start indexing panes'
|
|
'pane-border-style:style of border pane'
|
|
"remain-on-exit:don't destroy windows after the program exits"
|
|
'synchronize-panes:send input to all panes of a window'
|
|
'utf8:assume UTF-8 sequences to appear in a window'
|
|
'window-active-style:style of active window'
|
|
'window-status-activity-style:style of status bar activity tag'
|
|
'window-status-bell-style:style of status bar bell tag'
|
|
'window-status-current-format:set status line format for active window'
|
|
'window-status-current-style:style of current window in status bar'
|
|
'window-status-format:set status line format for all but the active window'
|
|
'window-status-last-style:style of last window in status bar'
|
|
'window-status-separator:separator drawn between windows in status line'
|
|
'window-status-style:general status bar style'
|
|
'window-style:style of window'
|
|
'wrap-search:search wrap around at the end of a pane'
|
|
'xterm-keys:generate xterm-style function key sequences'
|
|
)
|
|
_describe -t tmux-window-options 'tmux window option' tmux_window_options
|
|
}
|
|
|
|
function __tmux-windows() {
|
|
local expl
|
|
local -a wins opts
|
|
|
|
compset -P '*:'
|
|
if [[ -n ${IPREFIX} ]]; then
|
|
opts=( -t "${IPREFIX%:}" )
|
|
else
|
|
opts=( )
|
|
fi
|
|
wins=( ${${(M)${(f)"$(command tmux 2> /dev/null list-windows "${opts[@]}")"}:#<->*}/:[ $'\t']##/:} )
|
|
_describe -t windows 'windows' wins "$@"
|
|
if [[ ${IPREFIX} != *: ]]; then
|
|
_wanted sessions expl 'sessions' __tmux-sessions -S:
|
|
fi
|
|
}
|
|
|
|
# And here is the actual _tmux(), that puts it all together:
|
|
_tmux() {
|
|
local curcontext="${curcontext}" state line ret=1
|
|
local mode
|
|
local tmuxcommand
|
|
local tmux_describe
|
|
|
|
_arguments -C -s -w \
|
|
'-2[force using 256 colours]' \
|
|
'-c[execute a shell command]:command name:_command_names' \
|
|
'-C[start tmux in control mode. -CC disables echo]' \
|
|
'-f[specify configuration file]:tmux config file:_files -g "*(-.)"' \
|
|
'-l[behave like a login shell]' \
|
|
'-L[specify socket name]:socket name:__tmux-socket-name' \
|
|
'-S[specify socket path]:server socket:_path_files -g "*(=,/)"' \
|
|
'-u[force using UTF-8]' \
|
|
'-v[request verbose logging]' \
|
|
'-V[report tmux version]' \
|
|
'*:: :->subcommand_or_options' && ret=0
|
|
|
|
[[ -z $state ]] && return ret
|
|
|
|
if (( CURRENT == 1 )); then
|
|
zstyle -s ":completion:${curcontext}:subcommands" mode mode || mode='both'
|
|
if [[ ${mode} == 'commands' ]]; then
|
|
_describe -t subcommands 'tmux commands' _tmux_commands && ret=0
|
|
elif [[ ${mode} == 'aliases' ]]; then
|
|
_describe -t subcommands 'tmux aliases' _tmux_aliases && ret=0
|
|
else
|
|
_describe -t subcommands 'tmux commands and aliases' _tmux_commands -- _tmux_aliases && ret=0
|
|
fi
|
|
else
|
|
tmuxcommand="${words[1]}"
|
|
if [[ -n ${_tmux_aliasmap[$tmuxcommand]} ]] ; then
|
|
tmuxcommand="${_tmux_aliasmap[$tmuxcommand]}"
|
|
fi
|
|
if ! (( ${+functions[_tmux-$tmuxcommand]} )); then
|
|
local low high
|
|
low=$_tmux_commands[(i)$tmuxcommand*]
|
|
high=$_tmux_commands[(I)$tmuxcommand*]
|
|
if (( low == high )); then
|
|
tmuxcommand=${_tmux_commands[low]%%:*}
|
|
elif (( low < high )); then
|
|
_message "ambiguous command $tmuxcommand"
|
|
else
|
|
_message "subcommand $tmuxcommand not known"
|
|
_normal && ret=0
|
|
fi
|
|
fi
|
|
curcontext="${curcontext%:*}-${tmuxcommand}:"
|
|
_call_function ret _tmux-${tmuxcommand}
|
|
fi
|
|
return ret
|
|
}
|
|
|
|
# description generation follows; only done on 1st _tmux call.
|
|
local f desc
|
|
local -A rev
|
|
local tmux_describe
|
|
tmux_describe='yes, please'
|
|
for f in ${(k)_tmux_aliasmap} ; do
|
|
rev+=( ${_tmux_aliasmap[$f]} $f )
|
|
done
|
|
for f in ${(M)${(k)functions}:#_tmux-*} ; do
|
|
desc="$($f)"
|
|
_tmux_commands+=( "${f#_tmux-}${desc:+:$desc}" )
|
|
[[ -n ${rev[${f#_tmux-}]} ]] && _tmux_aliases+=( "${rev[${f#_tmux-}]}${desc:+:$desc}" )
|
|
done
|
|
|
|
_tmux "$@"
|