Current File : //usr/share/zsh/5.0.2/functions/_tmux
#compdef tmux
# tmux <http://tmux.sf.net> 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>:*:*'
# 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
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
downp down-pane
findw find-window
joinp join-pane
killp kill-pane
killw kill-window
last last-window
linkw link-window
lsp list-panes
lsw list-windows
movew move-window
neww new-window
nextl next-layout
next next-window
pipep pipe-pane
prev previous-window
renamew rename-window
resizep resize-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
upp up-pane
# 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
copyb copy-buffer
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
)
# --- Sub-command functions ---
# These *must* be called _tmux-*(); The description generation relies on
# them being names 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].
function _tmux-attach-session() {
[[ -n ${tmux_describe} ]] && print "Attach or switch to a session" && return
local -a args
args=(
'-d[detach other clients attached to target session]'
'-r[put the client into read-only mode]'
'-t[choose a target session]:target session:__tmux-sessions'
)
_arguments ${args}
}
function _tmux-bind-key() {
[[ -n ${tmux_describe} ]] && print "Bind a key to a command" && return
local curcontext="${curcontext}" state
local -a args
args=(
'-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[choose a key table for the binding]:key tables:__tmux-key-tables'
'1: :->key'
'*:: :->command_and_args'
)
_arguments -C ${args} && return
if [[ ${state} == 'key' ]]; then
_message "key"
else
# quite cool, that this works. :-)
_tmux
fi
}
function _tmux-break-pane() {
[[ -n ${tmux_describe} ]] && print "Break a pane from an existing into a new window" && return
local -a args
args=(
'-d[do not make the new window become the active one]'
'-t[choose a target pane]:panes:__tmux-panes'
)
_arguments ${args}
}
function _tmux-capture-pane() {
[[ -n ${tmux_describe} ]] && print "Capture the contents of a pane to a buffer" && return
local -a args
args=(
'-b[choose target buffer]:target buffer:__tmux-buffers'
'-t[choose source pane]:source pane:__tmux-panes'
)
_arguments ${args}
}
function _tmux-choose-client() {
[[ -n ${tmux_describe} ]] && print "Put a window into client choice mode" && return
__tmux-choose-stuff
}
function _tmux-choose-session() {
[[ -n ${tmux_describe} ]] && print "Put a window into session choice mode" && return
__tmux-choose-stuff
}
function _tmux-choose-window() {
[[ -n ${tmux_describe} ]] && print "Put a window into window choice mode" && return
__tmux-choose-stuff
}
function _tmux-clear-history() {
[[ -n ${tmux_describe} ]] && print "Remove and clear history for a pane" && return
local -a args
args=('-t[choose a target pane]:panes:__tmux-panes')
_arguments ${args}
}
function _tmux-clock-mode() {
[[ -n ${tmux_describe} ]] && print "Enter clock mode" && return
local -a args
args=('-t[choose a target pane]:panes:__tmux-panes')
_arguments ${args}
}
function _tmux-command-prompt() {
[[ -n ${tmux_describe} ]] && print "Open the tmux command prompt in a client" && return
local state
local -a args
args=(
'-p[list of prompts]:prompts:->plist'
'-t[choose a target client]:clients:__tmux-clients'
'*:: :->tmpl'
)
_arguments -C ${args} && return
if [[ ${state} == 'plist' ]]; then
_message "comma seperated list of prompts"
return
fi
__tmux-lastarg ${state} 'tmpl' 1 "command template"
}
function _tmux-confirm-before() {
[[ -n ${tmux_describe} ]] && print "Run a command but ask for confirmation before" && return
local state
local -a args
args=(
'-t[choose a target client]:clients:__tmux-clients'
'*:: :->command_and_args'
)
_arguments -C ${args} && return
__tmux-lastarg ${state} 'command_and_args' 1 "command string"
}
function _tmux-copy-buffer() {
[[ -n ${tmux_describe} ]] && print "Copy session paste buffers" && return
local state session
local -a args
local -ax bopts
args=(
'-a[choose a source buffer index]:buffer:->srcbuf'
'-b[choose a destination buffer index]:buffer:->dstbuf'
'-s[choose a source session]:session:->srcsession'
'-t[choose a destination session]:session:->dstsession'
)
_arguments ${args}
case ${state} in
((src|dst)session)
__tmux-sessions
return
;;
(srcbuf)
session="$(__tmux-get-optarg -s "${words[@]}")"
;;
(srcbuf)
session="$(__tmux-get-optarg -t "${words[@]}")"
;;
esac
if [[ -n ${session} ]]; then
bopts=( -t ${session} )
__tmux-buffers
return
fi
bopts=()
__tmux-buffers
}
function _tmux-copy-mode() {
[[ -n ${tmux_describe} ]] && print "Enter copy mode" && return
local -a args
args=(
'-t[choose a target pane]:panes:__tmux-panes'
'-u[scroll up one page]'
)
_arguments ${args}
}
function _tmux-delete-buffer() {
[[ -n ${tmux_describe} ]] && print "Delete a paste buffer" && return
local state session
local -a args
local -ax bopts
args=(
'-b[choose a target buffer index]:panes:->buffer'
'-t[choose a target session]:panes:->session'
)
_arguments ${args}
case ${state} in
(session)
__tmux-sessions
return
;;
(buffer)
session="$(__tmux-get-optarg -t "${words[@]}")"
;;
(*) return ;;
esac
if [[ -n ${session} ]]; then
bopts=( -t ${session} )
__tmux-buffers
return
fi
bopts=()
__tmux-buffers
}
function _tmux-detach-client() {
[[ -n ${tmux_describe} ]] && print "Detach a client from the server" && return
local -a args
args=('-t[choose a target client]:clients:__tmux-clients')
_arguments ${args}
}
function _tmux-display-message() {
[[ -n ${tmux_describe} ]] && print "Display a message in the status line" && return
local -a args
args=(
'-p[print message to stdout]'
'-t[choose a target client]:clients:__tmux-clients'
'*:: :->msg'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'msg' 1 "message"
}
function _tmux-display-panes() {
[[ -n ${tmux_describe} ]] && print "Display an indicator for each visible pane" && return
local -a args
args=('-t[choose a target client]:clients:__tmux-clients')
_arguments ${args}
}
function _tmux-down-pane() {
[[ -n ${tmux_describe} ]] && print "Move down a pane" && return
local -a args
args=('-t[choose a target pane]:panes:__tmux-panes')
_arguments ${args}
}
function _tmux-find-window() {
[[ -n ${tmux_describe} ]] && print "Search for a pattern in windows" && return
local curcontext="${curcontext}" state
local -a args
args=(
'-t[choose a target window]:windows:__tmux-windows'
'*:: :->pattern'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'pattern' 1 "window search pattern"
}
function _tmux-has-session() {
[[ -n ${tmux_describe} ]] && print "Check and report if a session exists on the server" && return
local -a args
args=('-t[choose a target session]:sessions:__tmux-sessions')
_arguments ${args}
}
function _tmux-if-shell() {
[[ -n ${tmux_describe} ]] && print "Execute a tmux command if a shell-command succeeded" && return
local -a args
args=(
'1:shell command:'
'2:tmux command:'
)
_arguments ${args}
}
function _tmux-join-pane() {
[[ -n ${tmux_describe} ]] && print "Split a pane and move an existing one into the new space" && return
local -a args
args=(
'-d[do not 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[choose source pane]:window:__tmux-panes'
'-t[choose target pane]:window:__tmux-panes'
)
_arguments ${args} && return
}
function _tmux-kill-pane() {
[[ -n ${tmux_describe} ]] && print "Destroy a given pane" && return
local -a args
args=(
'-a[kill all panes, except current]'
'-t[choose a target pane]:panes:__tmux-panes'
)
_arguments ${args}
}
function _tmux-kill-server() {
[[ -n ${tmux_describe} ]] && print "Kill clients, sessions and server" && return
__tmux-nothing-else
}
function _tmux-kill-session() {
[[ -n ${tmux_describe} ]] && print "Destroy a given session" && return
local -a args
args=('-t[choose a target session]:sessions:__tmux-sessions')
_arguments ${args}
}
function _tmux-kill-window() {
[[ -n ${tmux_describe} ]] && print "Destroy a given window" && return
local -a args
args=('-t[choose a target window]:windows:__tmux-windows')
_arguments ${args}
}
function _tmux-last-window() {
[[ -n ${tmux_describe} ]] && print "Select the previously selected window" && return
local -a args
args=('-t[choose a session]:sessions:__tmux-sessions')
_arguments ${args} && return
}
function _tmux-link-window() {
[[ -n ${tmux_describe} ]] && print "Link a window to another" && return
local -a args
args=(
'-d[do not make the new window become the active one]'
'-k[kill the target window if it exists]'
'-s[choose source window]:window:__tmux-windows'
'-t[choose destination window]:window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-list-buffers() {
[[ -n ${tmux_describe} ]] && print "List paste buffers of a session" && return
local -a args
args=('-t[choose a session]:sessions:__tmux-sessions')
_arguments ${args} && return
}
function _tmux-list-clients() {
[[ -n ${tmux_describe} ]] && print "List clients attached to server" && return
__tmux-nothing-else
}
function _tmux-list-commands() {
[[ -n ${tmux_describe} ]] && print "List supported sub-commands" && return
__tmux-nothing-else
}
function _tmux-list-keys() {
[[ -n ${tmux_describe} ]] && print "List all key-bindings" && return
local -a args
args=('-t[choose a key table]:key table:__tmux-key-tables')
_arguments ${args} && return
}
function _tmux-list-panes() {
[[ -n ${tmux_describe} ]] && print "List panes of a window" && return
local -a args
args=('-t[choose a window]:windows:__tmux-windows')
_arguments ${args} && return
}
function _tmux-list-sessions() {
[[ -n ${tmux_describe} ]] && print "List sessions managed by server" && return
__tmux-nothing-else
}
function _tmux-list-windows() {
[[ -n ${tmux_describe} ]] && print "List windows of a session" && return
local -a args
args=('-t[choose a session]:sessions:__tmux-sessions')
_arguments ${args} && return
}
function _tmux-load-buffer() {
[[ -n ${tmux_describe} ]] && print "Load a file into a paste buffer" && return
local state session
local -a args
local -ax bopts
args=(
'-b[choose a target buffer index]:panes:->buffer'
'-t[choose a target session]:panes:->session'
'1:file name:_files -g "*(-.)"'
)
_arguments ${args}
case ${state} in
(session)
__tmux-sessions
return
;;
(buffer)
session="$(__tmux-get-optarg -t "${words[@]}")"
;;
(*) return ;;
esac
if [[ -n ${session} ]]; then
bopts=( -t ${session} )
__tmux-buffers
return
fi
bopts=()
__tmux-buffers
}
function _tmux-lock-client() {
[[ -n ${tmux_describe} ]] && print "Lock a client" && return
local -a args
args=('-t[choose a client]:clients:__tmux-clients')
_arguments ${args} && return
}
function _tmux-lock-server() {
[[ -n ${tmux_describe} ]] && print "Lock all clients attached to the server" && return
__tmux-nothing-else
}
function _tmux-lock-session() {
[[ -n ${tmux_describe} ]] && print "Lock all clients attached to a session" && return
local -a args
args=('-t[choose a session]:sessions:__tmux-sessions')
_arguments ${args} && return
}
function _tmux-move-window() {
[[ -n ${tmux_describe} ]] && print "Move a window to another" && return
local -a args
args=(
'-d[do not make the new window become the active one]'
'-s[choose source window]:window:__tmux-windows'
'-t[choose destination window]:window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-new-session() {
[[ -n ${tmux_describe} ]] && print "Create a new session" && return
local -a args
args=(
'-d[do not attach new session to current terminal]'
'-n[name the initial window]:window name'
'-s[name the session]:session name'
'-t[specify target session]:sessions:__tmux-sessions'
'*:: :_command'
)
_arguments ${args}
}
function _tmux-new-window() {
[[ -n ${tmux_describe} ]] && print "Create a new window" && return
local -a args
args=(
'-d[do not make the new window become the active one]'
'-k[destroy it if the specified window exists]'
'-n[specify a window name]:window name:'
'-t[specify target window]:windows:__tmux-windows'
'*:: :_command'
)
_arguments ${args}
}
function _tmux-next-layout() {
[[ -n ${tmux_describe} ]] && print "Move a window to the next layout" && return
local -a args
args=('-t[choose target window]:window:__tmux-windows')
_arguments ${args}
}
function _tmux-next-window() {
[[ -n ${tmux_describe} ]] && print "Move to the next window in a session" && return
local -a args
args=(
'-a[move to the next window with activity]'
'-t[choose target session]:session:__tmux-sessions'
)
_arguments ${args}
}
function _tmux-paste-buffer() {
[[ -n ${tmux_describe} ]] && print "Insert a paste buffer into the window" && return
local -a args
args=(
'-d[remove buffer from stack after pasting]'
'-r[do not replace LF with CR when pasting]'
'-b[choose buffer]:source buffer:__tmux-buffers'
'-t[choose target window]:window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-pipe-pane() {
[[ -n ${tmux_describe} ]] && print "Pipe output from a pane to a shell command" && return
local state
args=(
'-o[only open a pipe if none is currently opened]'
'-t[choose target pane]:pane:__tmux-panes'
'*:: :->cmd'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'cmd' 1 "command string"
}
function _tmux-previous-layout() {
[[ -n ${tmux_describe} ]] && print "Move a window to the previous layout" && return
local -a args
args=('-t[choose target window]:window:__tmux-windows')
_arguments ${args}
}
function _tmux-previous-window() {
[[ -n ${tmux_describe} ]] && print "Move to the previous window in a session" && return
local -a args
args=(
'-a[move to the previous window with activity]'
'-t[choose target session]:session:__tmux-sessions'
)
_arguments ${args}
}
function _tmux-refresh-client() {
[[ -n ${tmux_describe} ]] && print "Refresh a client" && return
local -a args
args=('-t[choose target client]:client:__tmux-clients')
_arguments ${args}
}
function _tmux-rename-session() {
[[ -n ${tmux_describe} ]] && print "Rename a session" && return
local state
args=(
'-t[choose target session]:session:__tmux-sessions'
'*:: :->name'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'name' 1 "new session name"
}
function _tmux-rename-window() {
[[ -n ${tmux_describe} ]] && print "Rename a window" && return
local state
args=(
'-t[choose target window]:window:__tmux-windows'
'*:: :->name'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'name' 1 "new window name"
}
function _tmux-resize-pane() {
[[ -n ${tmux_describe} ]] && print "Resize a pane" && return
args=(
'-D[resize downward]'
'-L[resize to the left]'
'-R[resize to the right]'
'-U[resize upward]'
'-t[choose target pane]:pane:__tmux-panes'
'1::adjustment (defaults to one):_guard "[0-9]#" "numeric value"'
)
_arguments ${args}
}
function _tmux-respawn-window() {
[[ -n ${tmux_describe} ]] && print "Reuse a window in which a command has exited" && return
local -a args
args=(
'-k[kill window if it is in use]'
'-t[choose target window]:window:__tmux-windows'
'*::command:_command'
)
_arguments ${args}
}
function _tmux-rotate-window() {
[[ -n ${tmux_describe} ]] && print "Rotate positions of panes in a window" && return
local -a args
args=(
'-D[rotate downward]'
'-U[rotate upward]'
'-t[choose target window]:window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-run-shell() {
[[ -n ${tmux_describe} ]] && print "Execute a command without creating a new window" && return
_command
}
function _tmux-save-buffer() {
[[ -n ${tmux_describe} ]] && print "Save a paste buffer to a file" && return
local state session
local -a args
local -ax bopts
args=(
'-b[choose a target buffer index]:buffer:->buffer'
'-t[choose a target session]:buffer:->session'
)
_arguments ${args}
case ${state} in
(session)
__tmux-sessions
return
;;
(buffer)
session="$(__tmux-get-optarg -t "${words[@]}")"
;;
(*) return ;;
esac
if [[ -n ${session} ]]; then
bopts=( -t ${session} )
__tmux-buffers
return
fi
bopts=()
__tmux-buffers
}
function _tmux-select-layout() {
[[ -n ${tmux_describe} ]] && print "Choose a layout for a window" && return
args=(
'-t[choose a target window]:target window:__tmux-windows'
'*::layout name:__tmux-layouts'
)
_arguments ${args}
}
function _tmux-select-pane() {
[[ -n ${tmux_describe} ]] && print "Make a pane the active one in the window" && return
local -a args
args=('-t[choose a target pane]:panes:__tmux-panes')
_arguments ${args} && return
}
function _tmux-select-prompt() {
[[ -n ${tmux_describe} ]] && print "Open a prompt to enter a window index" && return
local -a args
args=('-t[choose a target client]:clients:__tmux-clients')
_arguments ${args} && return
}
function _tmux-select-window() {
[[ -n ${tmux_describe} ]] && print "Select a window" && return
local -a args
args=('-t[choose a target window]:windows:__tmux-windows')
_arguments ${args} && return
}
function _tmux-send-keys() {
[[ -n ${tmux_describe} ]] && print "Send key(s) to a window" && return
local curcontext="${curcontext}" state
local -a args
args=(
'-t[choose a target pane]:panes:__tmux-panes'
'*:: :->key'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'key' 1 "key"
}
function _tmux-send-prefix() {
[[ -n ${tmux_describe} ]] && print "Send the prefix key to a window" && return
local -a args
args=('-t[choose a target pane]:panes:__tmux-panes')
_arguments ${args}
}
function _tmux-server-info() {
[[ -n ${tmux_describe} ]] && print "Show server information" && return
__tmux-nothing-else
}
function _tmux-set-buffer() {
[[ -n ${tmux_describe} ]] && print "Set contents of a paster buffer" && return
local state session
local -a args
local -ax bopts
args=(
'-b[choose a target buffer index]:panes:->buffer'
'-t[choose a target session]:panes:->session'
)
_arguments ${args}
case ${state} in
(session)
__tmux-sessions
return
;;
(buffer)
session="$(__tmux-get-optarg -t "${words[@]}")"
;;
(*) return ;;
esac
if [[ -n ${session} ]]; then
bopts=( -t ${session} )
__tmux-buffers
return
fi
bopts=()
__tmux-buffers
}
function _tmux-set-environment() {
[[ -n ${tmux_describe} ]] && print "(Un)Set an environment variable" && return
local state
local -a args
args=(
'-g[modify global environment]'
'-r[remove variable before starting new processes]'
'-u[unset a variable]'
'-t[choose a target session]:target session:__tmux-sessions'
'*:: :->name_or_value'
)
_arguments -C ${args}
case ${state} in
name_or_value)
if (( CURRENT == 1 )); then
_message 'name'
elif (( CURRENT == 2 )); then
_message 'value'
else
__tmux-nothing-else
fi
;;
esac
}
function _tmux-set-option() {
[[ -n ${tmux_describe} ]] && print "Set a session option" && return
local mode
local -a args
args=(
'-a[append to string options]'
'-g[set a global session option]'
'-u[unset a non-global option]'
'-w[change window (not session) options]'
'-s[change server (not session) options]'
'-t[choose a target session]:target session:__tmux-sessions'
'*:: :->name_or_value'
)
if __tmux-got-option-already -w; then
mode=window
elif __tmux-got-option-already -s; then
mode=server
else
mode=session
fi
_arguments -C ${args}
__tmux-options-complete ${mode} ${state}
}
function _tmux-set-window-option() {
[[ -n ${tmux_describe} ]] && print "Set a window option" && return
local -a args
args=(
'-a[append to string options]'
'-g[set a global window option]'
'-u[unset a non-global option]'
'-t[choose a target window]:target window:__tmux-windows'
'*:: :->name_or_value'
)
_arguments -C ${args}
__tmux-options-complete window ${state}
}
function _tmux-show-buffer() {
[[ -n ${tmux_describe} ]] && print "Display the contents of a paste buffer" && return
local state session
local -a args
local -ax bopts
args=(
'-b[choose a target buffer index]:panes:->buffer'
'-t[choose a target session]:panes:->session'
)
_arguments ${args}
case ${state} in
(session)
__tmux-sessions
return
;;
(buffer)
session="$(__tmux-get-optarg -t "${words[@]}")"
;;
(*) return ;;
esac
if [[ -n ${session} ]]; then
bopts=( -t ${session} )
__tmux-buffers
return
fi
bopts=()
__tmux-buffers
}
function _tmux-show-environment() {
[[ -n ${tmux_describe} ]] && print "Display the environment" && return
local -a args
args=(
'-g[show global environment]'
'-t[choose a target session]:target session:__tmux-sessions'
)
_arguments ${args}
}
function _tmux-show-messages() {
[[ -n ${tmux_describe} ]] && print "Show client"\'"s message log" && return
args=('-t[choose target client]:client:__tmux-clients')
_arguments ${args}
}
function _tmux-show-options() {
[[ -n ${tmux_describe} ]] && print "Show session options" && return
local -a args
args=(
'-g[show global options]'
'-t[choose a target session]:target session:__tmux-sessions'
)
_arguments ${args}
}
function _tmux-show-window-options() {
[[ -n ${tmux_describe} ]] && print "Show window options" && return
local -a args
args=(
'-g[show global options]'
'-t[choose a target window]:target window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-source-file() {
[[ -n ${tmux_describe} ]] && print "Execute tmux commands from a file" && return
_files -g "*(-.)"
}
function _tmux-split-window() {
[[ -n ${tmux_describe} ]] && print "Splits a pane into two" && return
local -a args
args=(
'-d[do not 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"'
# Yes, __tmux_pane 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.
'-t[choose target pane]:window:__tmux-panes'
'*:: :_command'
)
_arguments ${args} && return
}
function _tmux-start-server() {
[[ -n ${tmux_describe} ]] && print "Start a tmux server" && return
__tmux-nothing-else
}
function _tmux-suspend-client() {
[[ -n ${tmux_describe} ]] && print "Suspend a client" && return
local -a args
args=('-t[choose destination client]:client:__tmux-clients')
_arguments ${args}
}
function _tmux-swap-pane() {
[[ -n ${tmux_describe} ]] && print "Swap two panes" && return
local -a args
args=(
'-D[move pane down]'
'-U[move pane up]'
'-d[do not change the active pane]'
'-s[choose source pane]:pane:__tmux-panes'
'-t[choose destination pane]:pane:__tmux-panes'
)
_arguments ${args}
}
function _tmux-swap-window() {
[[ -n ${tmux_describe} ]] && print "Swap two windows" && return
local -a args
args=(
'-d[do not make the new window become the active one]'
'-s[choose source window]:window:__tmux-windows'
'-t[choose destination window]:window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-switch-client() {
[[ -n ${tmux_describe} ]] && print "Switch the client to another session" && return
local -a args
args=(
'-c[choose a target client]:client:__tmux-clients'
'-t[choose a target window]:window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-unbind-key() {
[[ -n ${tmux_describe} ]] && print "Unbind a key" && return
local state keytable
local -a args ow
ow=( "${words[@]}" )
args=(
'-c[kill the window if it is only in one session]'
'-n[remove a non-prefix binding]'
'-t[choose a key table]:key table:__tmux-key-tables'
'*:: :->boundkeys'
)
_arguments ${args} && return
[[ ${state} != 'boundkeys' ]] && return
keytable="$(__tmux-get-optarg -t "${ow[@]}")"
if [[ -n ${keytable} ]]; then
__tmux-bound-keys -t ${keytable}
return
fi
__tmux-bound-keys
}
function _tmux-unlink-window() {
[[ -n ${tmux_describe} ]] && print "Unlink a window" && return
local -a args
args=(
'-k[kill the window if it is only in one session]'
'-t[choose a target window]:target window:__tmux-windows'
)
_arguments ${args}
}
function _tmux-up-pane() {
[[ -n ${tmux_describe} ]] && print "Move up a pane" && return
local -a args
args=('-t[choose a target pane]:panes:__tmux-panes')
_arguments ${args}
}
# --- 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-choose-stuff() {
# choose-{client,session,window} accept exactly the same arguments, so...
local curcontext="${curcontext}" state
local -a args
args=(
'-t[choose a target pane]:panes:__tmux-panes'
'*:: :->tmpl'
)
_arguments ${args} && return
__tmux-lastarg ${state} 'tmpl' 1 "tmux command template"
}
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-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
}
function __tmux-got-option-already() {
[[ -n ${(M)words:#$1} ]] && return 0
return 1
}
function __tmux-key-tables() {
local expl
local -a tables
tables=( vi-edit emacs-edit vi-choice emacs-choice vi-copy emacs-copy )
_wanted keytable expl 'key tables' compadd ${expl} -- ${tables}
}
function __tmux-lastarg() {
local got_state="$1" want_state="$2" pos="$3" msg="$4"
if [[ ${want_state} == ${got_state} ]] && (( CURRENT == ${pos} )); then
_message ${msg}
else
__tmux-nothing-else
fi
}
function __tmux-layouts() {
local expl
local -a layouts
layouts=( even-horizontal even-vertical main-horizontal main-vertical )
_wanted layout expl 'layouts' compadd ${expl} -- ${layouts}
}
function __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=(
'base-index:'${int_guard}
'bell-action:DESC:any none current'
'buffer-limit:'${int_guard}
'default-command:MSG:command string'
'default-path:MSG:path name'
'default-shell:MSG:shell executable'
'default-terminal:MSG:terminal string'
'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'
'lock-server:DESC:on off'
'message-attr:__tmux-attributes'
'message-bg:__tmux-colours'
'message-fg:__tmux-colours'
'message-limit:'${int_guard}
'mouse-select-pane:DESC:on off'
'pane-border-bg:__tmux-colours'
'pane-border-fg:__tmux-colours'
'pane-active-border-bg:__tmux-colours'
'pane-active-border-fg:__tmux-colours'
'prefix:MSG:comma-seperated key list'
'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-attr:__tmux-attributes'
'status-bg:__tmux-colours'
'status-fg:__tmux-colours'
'status-interval:'${int_guard}
'status-justify:DESC:left centre right'
'status-keys:DESC:vi emacs'
'status-left:MSG:format string'
'status-left-attr:__tmux-attributes'
'status-left-bg:__tmux-colours'
'status-left-fg:__tmux-colours'
'status-left-length:'${int_guard}
'status-right:MSG:format string'
'status-right-attr:__tmux-attributes'
'status-right-bg:__tmux-colours'
'status-right-fg:__tmux-colours'
'status-right-length:'${int_guard}
'status-utf8:DESC:on off'
'terminal-overrides:MSG:overrides string'
'update-environment:MSG:string listing env. variables'
'visual-activity:DESC:on off'
'visual-bell:DESC:on off'
'visual-content:DESC:on off'
)
elif [[ ${mode} == 'server' ]]; then
options=(
'escape-time:'${int_guard}
'quiet:DESC:on off'
)
else
options=(
'aggressive-resize:DESC:on off'
'alternate-screen:DESC:on off'
'automatic-rename:DESC:on off'
'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-attr:__tmux-attributes'
'mode-bg:__tmux-colours'
'mode-fg:__tmux-colours'
'mode-keys:DESC:vi emacs'
'mode-mouse:DESC:on off'
'monitor-activity:DESC:on off'
'monitor-content:MSG:fnmatch(3) pattern'
'remain-on-exit:DESC:on off'
'synchronize-panes:DESC:on off'
'utf8:DESC:on off'
'window-status-attr:__tmux-attributes'
'window-status-bg:__tmux-colours'
'window-status-current-attr:__tmux-attributes'
'window-status-current-bg:__tmux-colours'
'window-status-current-fg:__tmux-colours'
'window-status-current-format:MSG:status format string'
'window-status-fg:__tmux-colours'
'window-status-format:MSG:status format string'
'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-options() {
local -a tmux_options
tmux_options=(
'base-index:define where to start numbering'
'bell-action:set action on window bell'
'buffer-limit:number of buffers kept per session'
'default-command:default command for new windows'
'default-path:default working directory'
'default-shell:default shell executable'
'default-terminal:default terminal definition string'
'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'
'lock-server:make lock-after-time lock the server instead of sessions'
'message-attr:set status line message attributes'
'message-bg:set status line message background colour'
'message-fg:set status line message foreground colour'
'message-limit:set size of message log per client'
'mouse-select-pane:make mouse clicks select window panes'
'pane-border-bg:set pane border foreground colour'
'pane-border-fg:set pane border background colour'
'pane-active-border-bg:set active pane border foreground colour'
'pane-active-border-fg:set active pane border background colour'
'prefix:comma seperated line of keys accepted as prefix key'
'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-attr:status bar attributes'
'status-bg:status bar background colour'
'status-fg:status bar foreground colour'
'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-attr:attribute for the left part of the status bar'
'status-left-bg:background colour of the left part of the status bar'
'status-left-fg:foreground colour of the left part of the status bar'
'status-left-length:maximum length of the left part of the status bar'
'status-right:format to use right in status bar'
'status-right-attr:attribute for the right part of the status bar'
'status-right-bg:background colour of the right part of the status bar'
'status-right-fg:foreground colour of the right part of the status bar'
'status-right-length:maximum length of the right part of the status bar'
'status-utf8:assume UTF-8 sequences to appear in status bar'
'terminal-overrides:override terminal descriptions'
'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-content:display status line messages upon content changes'
)
_describe -t tmux-options 'tmux option' tmux_options
}
function __tmux-options-complete() {
local mode="$1" state="$2"
case ${state} in
name_or_value)
if (( CURRENT == 1 )) && [[ ${mode} == 'session' ]]; then
__tmux-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=(
'escape-time:set timeout to detect single escape characters (in msecs)'
'quiet:enable/disable the display of various informational messages'
)
_describe -t tmux-server-options 'tmux server option' tmux_server_options
}
function __tmux-sessions() {
local expl
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="/tmp/tmux-${UID}"
socks=(${sdir}/*(=:t))
_wanted socket expl 'socket name' compadd ${expl} -- ${socks}
}
function __tmux-window-options() {
local -a tmux_window_options
tmux_window_options=(
'aggressive-resize:aggressively resize windows'
'alternate-screen:allow alternate screen feature to be used'
'automatic-rename:attempt to automatically rename windows'
'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-attr:set window modes attributes'
'mode-bg:set window modes background colour'
'mode-fg:set window modes foreground colour'
'mode-keys:mode to use in copy and choice modes (vi/emacs)'
'mode-mouse:use mouse in modes'
'monitor-activity:monitor window activity'
'monitor-content:monitor window contents for a fnmatch(3) pattern'
'remain-on-exit:do not 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-status-attr:set status line attributes for a window'
'window-status-bg:set status line background for a window'
'window-status-current-attr:set status line attributes for active window'
'window-status-current-bg:set status line background for active window'
'window-status-current-fg:set status line foreground for active window'
'window-status-current-format:set status line format for active window'
'window-status-fg:set status line foreground for a window'
'window-status-format:set status line format for all but the active window'
'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:
function _tmux() {
local curcontext="${curcontext}"
local mode state ret
local -a args
local -x tmuxcommand
unset tmux_describe
args=(
'-2[force using 256 colours]'
'-8[force using 88 colours]'
'-c[execute a shell command]:command name:_command_names'
'-f[specify configuration file]:tmux config file:_files -g "*(-.)"'
'-l[behave like a login shell]'
'-L[specify socket name]:socket name:__tmux-socket-name'
'-q[do not send informational messages]'
'-S[specify socket path]:server socket:_path_files -g "*(=,/)"'
'-u[force using UTF-8]'
'-v[request verbose logging]'
'*:: :->subcommand_or_options'
)
_arguments -C -s -w ${args} && return
if [[ ${state} == "subcommand_or_options" ]]; then
if (( CURRENT == 1 )) ; then
zstyle -s ":completion:${curcontext}:subcommands" mode mode || mode='both'
if [[ ${mode} == 'commands' ]]; then
_describe -t subcommands 'tmux commands' _tmux_commands
elif [[ ${mode} == 'aliases' ]]; then
_describe -t subcommands 'tmux aliases' _tmux_aliases
else
_describe -t subcommands 'tmux commands and aliases' _tmux_commands -- _tmux_aliases
fi
else
if (( ${+commands[tmux]} == 0 )); then
_message '`tmux'\'' not found in $path; sub-cmd completions disabled.'
return 0
fi
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 -e "Ambiguous command $tmuxcommand"
else
_message -e "Subcommand $tmuxcommand not known"
fi
fi
curcontext="${curcontext%:*:*}:tmux-${tmuxcommand}:"
_call_function ret _tmux-${tmuxcommand}
fi
fi
}
# description generation follows; only done on 1st _tmux call.
local f desc
local -A rev
local -x 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
unset desc f rev tmux_describe
_tmux
Mini Shell