Struct tmux_interface::tmux_interface::TmuxInterface

pub struct TmuxInterface<'a> {
    pub environment: Option<&'a str>,
    pub tmux: Option<&'a str>,
    pub colours256: Option<bool>,
    pub control_mode: Option<bool>,
    pub disable_echo: Option<bool>,
    pub shell_cmd: Option<&'a str>,
    pub file: Option<&'a str>,
    pub socket_name: Option<&'a str>,
    pub login_shell: Option<bool>,
    pub socket_path: Option<&'a str>,
    pub force_utf8: Option<bool>,
    pub verbose_logging: Option<bool>,
    pub version: Option<bool>,
}

This structure is used to store execution parameters of tmux, including binary name. Full description of fields can be found using man tmux. man tmux

Fields

environment: Option<&'a str>

Environment variables for tmux

tmux: Option<&'a str>

Tmux binary name (default: tmux, can be set as tmux_mock.sh for "sniffing")

colours256: Option<bool>

Force tmux to assume the terminal supports 256 colours

control_mode: Option<bool>

Start in control mode

disable_echo: Option<bool>

Disables echo

shell_cmd: Option<&'a str>

Execute shell-command using the default shell

file: Option<&'a str>

Specify an alternative configuration file

socket_name: Option<&'a str>

Allows a different socket name to be specified

login_shell: Option<bool>

Behave as a login shell

socket_path: Option<&'a str>

Specify a full alternative path to the server socket

force_utf8: Option<bool>

Write UTF-8 output to the terminal

verbose_logging: Option<bool>

Request verbose logging

version: Option<bool>

Report the tmux version

Methods

impl<'a> TmuxInterface<'a>

Common TmuxInterface functions

pub fn new() -> Self

Create new TmuxInterface instance initialized with default values

pub fn subcommand(
    &self,
    subcmd: &str,
    args: &[&str]
) -> Result<Output, TmuxInterfaceError>

Execute subcommand of tmux

Manual

tmux [-2CluvV] [-c shell-command] [-f file] [-L socket-name] [-S socket-path]
[command [flags]]

Examples

use crate::tmux_interface::TmuxInterface;

let tmux = TmuxInterface::new();
tmux.subcommand("has-session", &["-t", "session_name"]).unwrap();

pub fn exec(&self, args: &[&str]) -> Result<Output, TmuxInterfaceError>

pub fn version(&self) -> Result<(usize, usize), TmuxInterfaceError>

Manual

tmux -V

impl<'a> TmuxInterface<'a>

Windows and panes man tmux

pub fn copy_mode(
    &self,
    mouse_drag: Option<bool>,
    bottom_exit: Option<bool>,
    page_up: Option<bool>,
    target_pane: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Enter copy mode

Manual

tmux copy-mode [-Meu] [-t target-pane]

pub fn break_pane(
    &self,
    break_pane: &BreakPane
) -> Result<Output, TmuxInterfaceError>

Break src-pane off from its containing window to make it the only pane in dst-window

Manual

tmux break-pane [-dP] [-F format] [-n window-name] [-s src-pane] [-t dst-window]
(alias: breakp)

pub fn capture_pane(
    &self,
    capture_pane: &CapturePane
) -> Result<Output, TmuxInterfaceError>

Capture the contents of a pane

Manual

tmux capture-pane [-aepPqCJ] [-b buffer-name] [-E end-line] [-S start-line]
[-t target-pane]
(alias: capturep)

pub fn choose_client(
    &self,
    choose_client: &ChooseClient
) -> Result<Output, TmuxInterfaceError>

Put a pane into client mode, allowing a client to be selected interactively from a list

Manual

tmux choose-client [-NZ] [-F format] [-f filter] [-O sort-order] [-t target-pane]
[template]

pub fn choose_tree(
    &self,
    choose_tree: &ChooseTree
) -> Result<Output, TmuxInterfaceError>

Put a pane into tree mode, where a session, window or pane may be chosen interactively from a list

Manual

tmux choose-tree [-GNswZ] [-F format] [-f filter] [-O sort-order] [-t target-pane]
[template]

pub fn display_panes(
    &self,
    not_block: Option<bool>,
    duration: Option<&str>,
    target_client: Option<&str>,
    template: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Display a visible indicator of each pane shown by target-client

Manual

tmux display-panes [-b] [-d duration] [-t target-client] [template] (alias: displayp)

pub fn find_window(
    &self,
    find_window: &FindWindow
) -> Result<Output, TmuxInterfaceError>

Search for the fnmatch(3) pattern match-string in window names, titles, and visible content (but not history)

Manual

tmux find-window [-CNTZ] [-t target-pane] match-string
(alias: findw)

pub fn join_pane(
    &self,
    join_pane: &JoinPane
) -> Result<Output, TmuxInterfaceError>

Like split-window, but instead of splitting dst-pane and creating a new pane, split it and move src-pane into the space

Manual

tmux join-pane [-bdhv] [-l size | -p percentage] [-s src-pane] [-t dst-pane]
(alias: joinp)

pub fn kill_pane(
    &self,
    all: Option<bool>,
    target_pane: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Destroy the given pane

Manual

tmux kill-pane [-a] [-t target-pane]
(alias: killp)

pub fn kill_window(
    &self,
    all: Option<bool>,
    target_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Kill the current window or the window at target-window, removing it from any sessions to which it is linked

Manual

tmux kill-window [-a] [-t target-window]
(alias: killw)

pub fn last_pane(
    &self,
    disable: Option<bool>,
    enable: Option<bool>,
    target_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Select the last (previously selected) pane

Manual

tmux last-pane [-de] [-t target-window]
(alias: lastp)

pub fn last_window(
    &self,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Select the last (previously selected) window

Manual

tmux last-window [-t target-session]
(alias: last)

pub fn link_window(
    &self,
    link_window: &LinkWindow
) -> Result<Output, TmuxInterfaceError>

Link the window at src-window to the specified dst-window

Manual

tmux link-window [-adk] [-s src-window] [-t dst-window]
(alias: linkw)

pub fn list_panes(
    &self,
    all: bool,
    session: bool,
    format: Option<&str>,
    target: Option<&str>
) -> Result<String, TmuxInterfaceError>

List panes on the server

Manual

tmux list-panes [-as] [-F format] [-t target]
(alias: lsp)

pub fn list_windows(
    &self,
    all: bool,
    format: Option<&str>,
    target_session: Option<&str>
) -> Result<String, TmuxInterfaceError>

List windows on the server

Manual

tmux list-windows [-a] [-F format] [-t target-session]
(alias: lsw)

pub fn move_pane(
    &self,
    move_pane: &MovePane
) -> Result<Output, TmuxInterfaceError>

Like join-pane, but src-pane and dst-pane may belong to the same window

Manual

tmux move-pane [-bdhv] [-l size | -p percentage] [-s src-pane] [-t dst-pane]
(alias: movep)

pub fn move_window(
    &self,
    move_window: &MoveWindow
) -> Result<Output, TmuxInterfaceError>

This is similar to link-window, except the window at src-window is moved to dst-window

Manual

tmux move-window [-ardk] [-s src-window] [-t dst-window]
(alias: movew)

pub fn new_window(
    &self,
    new_window: NewWindow
) -> Result<Output, TmuxInterfaceError>

Create a new window

Manual

tmux new-window [-adkP] [-c start-directory] [-F format] [-n window-name]
[-t target-window] [shell-command]
(alias: neww)

pub fn next_layout(
    &self,
    target_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Move a window to the next layout and rearrange the panes to fit

Manual

tmux next-layout [-t target-window]
(alias: nextl)

pub fn next_window(
    &self,
    alert: Option<bool>,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Move to the next window in the session

Manual

tmux next-window [-a] [-t target-session] (alias: next)

pub fn pipe_pane(
    &self,
    pipe_pane: &PipePane
) -> Result<Output, TmuxInterfaceError>

Pipe output sent by the program in target-pane to a shell command or vice versa

Manual

tmux pipe-pane [-IOo] [-t target-pane] [shell-command]
(alias: pipep)

pub fn previous_layout(
    &self,
    target_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Move to the previous layout in the session

Manual

tmux previous-layout [-t target-window]
(alias: prevl)

pub fn previous_window(
    &self,
    alert: Option<bool>,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Move to the previous window in the session

Manual

tmux previous-window [-a] [-t target-session]
(alias: prev)

pub fn rename_window(
    &self,
    target_window: Option<&str>,
    new_name: &str
) -> Result<Output, TmuxInterfaceError>

Rename the current window, or the window at target-window if specified, to new-name

Manual

tmux rename-window [-t target-window] new-name
(alias: renamew)

pub fn resize_pane(
    &self,
    resize_pane: &ResizePane
) -> Result<Output, TmuxInterfaceError>

Resize a pane, up, down, left or right

Manual

tmux resize-pane [-DLMRUZ] [-t target-pane] [-x width] [-y height] [adjustment]
(alias: resizep)

pub fn resize_window(
    &self,
    resize_window: &ResizeWindow
) -> Result<Output, TmuxInterfaceError>

Resize a window, up, down, left or right

Manual

tmux resize-window [-aADLRU] [-t target-window] [-x width] [-y height] [adjustment]
(alias: resizew)

pub fn respawn_pane(
    &self,
    respawn_pane: &RespawnPane
) -> Result<Output, TmuxInterfaceError>

Reactivate a pane in which the command has exited

Manual

tmux respawn-pane [-k] [-c start-directory] [-e environment] [-t target-pane]
[shell-command]
(alias: respawnp)

pub fn respawn_window(
    &self,
    respawn_window: &RespawnWindow
) -> Result<Output, TmuxInterfaceError>

Reactivate a window in which the command has exited

Manual

tmux respawn-window [-k] [-c start-directory] [-e environment] [-t target-window]
[shell-command]
(alias: respawnw)

pub fn rotate_window(
    &self,
    down: Option<bool>,
    up: Option<bool>,
    target_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Rotate the positions of the panes within a window

Manual

tmux rotate-window [-DU] [-t target-window]
(alias: rotatew)

pub fn select_layout(
    &self,
    select_layout: &SelectLayot
) -> Result<Output, TmuxInterfaceError>

Choose a specific layout for a window

Manual

tmux select-layout [-Enop] [-t target-pane] [layout-name]
(alias: selectl)

pub fn select_pane(
    &self,
    select_pane: &SelectPane
) -> Result<Output, TmuxInterfaceError>

Make pane target-pane the active pane in window target-window

Manual

tmux select-pane [-DdegLlMmRU] [-P style] [-T title] [-t target-pane]
(alias: selectp)

pub fn select_window(
    &self,
    select_window: &SelectWindow
) -> Result<Output, TmuxInterfaceError>

Select the window at target-window

Manual

tmux select-window [-lnpT] [-t target-window]
(alias: selectw)

pub fn split_window(
    &self,
    split_window: &SplitWindow
) -> Result<Output, TmuxInterfaceError>

Create a new pane by splitting target-pane

Manual

tmux split-window [-bdfhvP] [-c start-directory] [-l size | -p percentage]
[-t target-pane] [shell-command] [-F format]
(alias: splitw)

pub fn swap_pane(
    &self,
    swap_pane: &SwapPane
) -> Result<Output, TmuxInterfaceError>

Swap two panes

Manual

tmux swap-pane [-dDU] [-s src-pane] [-t dst-pane]
(alias: swapp)

pub fn swap_window(
    &self,
    detached: Option<bool>,
    src_window: Option<&str>,
    dst_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

This is similar to link-window, except the source and destination windows are swapped

Manual

tmux swap-window [-d] [-s src-window] [-t dst-window]
(alias: swapw)

pub fn unlink_window(
    &self,
    k: Option<bool>,
    target_window: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Unlink target-window

Manual

tmux unlink-window [-k] [-t target-window]
(alias: unlinkw)

impl<'a> TmuxInterface<'a>

All functions from man tmux "Clients and Sessions" listed below man tmux

pub fn attach_session(
    &self,
    attach_session: &AttachSession
) -> Result<Output, TmuxInterfaceError>

Create a new client in the current terminal and attach it to target-session

Manual

tmux attach-session [-dEr] [-c working-directory] [-t target-session]
(alias: attach)

pub fn detach_client(
    &self,
    detach_client: &DetachClient
) -> Result<Output, TmuxInterfaceError>

Detach the current client

Manual

tmux detach-client [-aP] [-E shell-command] [-s target-session] [-t target-client]
(alias: detach)

pub fn has_session(
    &self,
    target_session: Option<&str>
) -> Result<bool, TmuxInterfaceError>

Report if the specified session exist

Manual

tmux has-session [-t target-session]
(alias: has)

pub fn kill_server(&self) -> Result<Output, TmuxInterfaceError>

Kill the tmux server and clients and destroy all sessions

Manual

tmux kill-server

pub fn kill_session(
    &self,
    all: Option<bool>,
    clear_alerts: Option<bool>,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Destroy the given session

Manual

tmux kill-session [-aC] [-t target-session]

pub fn list_clients(
    &self,
    format: Option<&str>,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

List all clients attached to the server

Manual

tmux list-clients [-F format] [-t target-session]
(alias: lsc)

pub fn list_commands(
    &self,
    format: Option<&str>
) -> Result<Output, TmuxInterfaceError>

List the syntax of all commands supported by tmux

Manual

tmux list-commands [-F format]
(alias: lscm)

pub fn list_sessions(
    &self,
    format: Option<&str>
) -> Result<String, TmuxInterfaceError>

List all sessions managed by the server

Manual

tmux list-sessions [-F format]
(alias: ls)

pub fn lock_client(
    &self,
    target_client: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Lock target-client

Manual

tmux lock-client [-t target-client]
(alias: lockc)

pub fn lock_session(
    &self,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Lock all clients attached to target-session

Manual

tmux lock-session [-t target-session]
(alias: locks)

pub fn new_session(
    &self,
    new_session: &NewSession
) -> Result<Output, TmuxInterfaceError>

Create a new session with name session-name

Manual

tmux new-session [-AdDEP] [-c start-directory] [-F format] [-n window-name]
[-s session-name] [-t group-name] [-x width] [-y height] [shell-command]
(alias: new)

pub fn refresh_client(
    &self,
    refresh_client: &RefreshClient
) -> Result<Output, TmuxInterfaceError>

Refresh the current client

Manual

tmux refresh-client [-cDlLRSU] [-C width,height] [-t target-client] [adjustment]
(alias: refresh)

pub fn rename_session(
    &self,
    target_session: Option<&str>,
    new_name: &str
) -> Result<Output, TmuxInterfaceError>

Rename the session to new-name

Manual

tmux rename-session [-t target-session] new-name
(alias: rename)

pub fn show_messages(
    &self,
    jobs: Option<bool>,
    terminal: Option<bool>,
    target_client: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Show client messages or server information

Manual

tmux show-messages [-JT] [-t target-client]
(alias: showmsgs)

pub fn source_file(
    &self,
    quite: Option<bool>,
    path: &str
) -> Result<Output, TmuxInterfaceError>

Execute commands from path

Manual

tmux source-file [-q] path
(alias: source)

pub fn start_server(&self) -> Result<Output, TmuxInterfaceError>

Start the tmux server, if not already running, without creating any sessions

Manual

tmux start-server
(alias: start)

pub fn suspend_client(
    &self,
    target_client: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Suspend a client by sending SIGTSTP (tty stop)

Manual

tmux suspend-client [-t target-client]
(alias: suspendc)

pub fn switch_client(
    &self,
    switch_client: &SwitchClient
) -> Result<Output, TmuxInterfaceError>

Switch the current session for client target-client to target-session

Manual

tmux switch-client [-Elnpr] [-c target-client] [-t target-session] [-T key-table]
(alias: switchc)

impl<'a> TmuxInterface<'a>

Key bindings

pub fn bind_key(&self, bind_key: &BindKey) -> Result<Output, TmuxInterfaceError>

Manual

tmux bind-key [-nr] [-T key-table] key command [arguments]
(alias: bind)

pub fn list_keys(
    &self,
    key_table: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux list-keys [-T key-table]
(alias: lsk)

pub fn send_keys(
    &self,
    send_keys: &SendKeys
) -> Result<Output, TmuxInterfaceError>

Manual

tmux send-keys [-lMRX] [-N repeat-count] [-t target-pane] key ...
(alias: send)

pub fn send_prefix(
    &self,
    secondary: Option<bool>,
    target_pane: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux send-prefix [-2] [-t target-pane]

pub fn unbind_key(
    &self,
    all: Option<bool>,
    root: Option<bool>,
    key_table: Option<&str>,
    key: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux unbind-key [-an] [-T key-table] key
(alias: unbind)

impl<'a> TmuxInterface<'a>

Status line

pub fn command_prompt(
    &self,
    command_prompt: &CommandPrompt
) -> Result<Output, TmuxInterfaceError>

Manual

tmux command-prompt [-1i] [-I inputs] [-p prompts] [-t target-client] [template]

pub fn confirm_before(
    &self,
    prompt: Option<&str>,
    target_client: Option<&str>,
    command: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux confirm-before [-p prompt] [-t target-client] command
(alias: confirm)

pub fn display_message(
    &self,
    print: Option<bool>,
    target_client: Option<&str>,
    target_pane: Option<&str>,
    message: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux display-message [-p] [-c target-client] [-t target-pane] [message]
(alias: display)

impl<'a> TmuxInterface<'a>

Options

pub fn set_option(
    &self,
    set_option: &SetOption
) -> Result<Output, TmuxInterfaceError>

Manual

tmux set-option [-aFgoqsuw] [-t target-session | target-window] option value
(alias: set)

pub fn set_window_option(
    &self,
    set_window_option: &SetWindowOption
) -> Result<Output, TmuxInterfaceError>

Manual

tmux set-window-option [-aFgoqu] [-t target-window] option value
(alias: setw)

pub fn show_options(
    &self,
    show_options: &ShowOptions
) -> Result<String, TmuxInterfaceError>

Manual

tmux show-options [-gHqsvw] [-t target-session | target-window] [option]
(alias: show)

pub fn show_window_options(
    &self,
    global: Option<bool>,
    only_value: Option<bool>,
    target_window: Option<&str>,
    option: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux show-window-options [-gv] [-t target-window] [option]
(alias: showw)

impl<'a> TmuxInterface<'a>

Hooks

pub fn set_hook(&self, set_hook: &SetHook) -> Result<Output, TmuxInterfaceError>

Manual

tmux set-hook [-agRu] [-t target-session] hook-name command

pub fn show_hooks(
    &self,
    global: Option<bool>,
    target_session: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux show-hooks [-g] [-t target-session]

impl<'a> TmuxInterface<'a>

Buffers

pub fn choose_buffer(
    &self,
    choose_buffer: &ChooseBuffer
) -> Result<Output, TmuxInterfaceError>

Manual

tmux choose-buffer [-NZ] [-F format] [-f filter] [-O sort-order] [-t target-pane]
[template]

pub fn clear_history(
    &self,
    target_pane: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux clear-history [-t target-pane]
(alias: clearhist)

pub fn delete_buffer(
    &self,
    buffer_name: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux delete-buffer [-b buffer-name]
(alias: deleteb)

pub fn list_buffers(
    &self,
    format: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux list-buffers [-F format]
(alias: lsb)

pub fn load_buffer(
    &self,
    buffer_name: Option<&str>,
    path: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux load-buffer [-b buffer-name] path
(alias: loadb)

pub fn paste_buffer(
    &self,
    paste_buffer: &PasteBuffer
) -> Result<Output, TmuxInterfaceError>

Manual

tmux paste-buffer [-dpr] [-b buffer-name] [-s separator] [-t target-pane]
(alias: pasteb)

pub fn save_buffer(
    &self,
    append: Option<bool>,
    buffer_name: Option<&str>,
    path: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux save-buffer [-a] [-b buffer-name] path
(alias: saveb)

pub fn set_buffer(
    &self,
    append: Option<bool>,
    buffer_name: Option<&str>,
    new_buffer_name: Option<&str>,
    data: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux set-buffer [-a] [-b buffer-name] [-n new-buffer-name] data
(alias: setb)

pub fn show_buffer(
    &self,
    buffer_name: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux show-buffer [-b buffer-name]
(alias: showb)

impl<'a> TmuxInterface<'a>

Global and session environment

pub fn set_environment(
    &self,
    set_environment: &SetEnvironment
) -> Result<Output, TmuxInterfaceError>

Manual

tmux set-environment [-gru] [-t target-session] name [value]
(alias: setenv)

pub fn show_environment(
    &self,
    global: Option<bool>,
    shell_format: Option<bool>,
    target_session: Option<&str>,
    variable: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux show-environment [-gs] [-t target-session] [variable]
(alias: showenv)

impl<'a> TmuxInterface<'a>

Miscellaneous

pub fn clock_mode(
    &self,
    target_pane: Option<&str>
) -> Result<Output, TmuxInterfaceError>

Manual

tmux clock-mode [-t target-pane]

pub fn if_shell(&self, if_shell: &IfShell) -> Result<Output, TmuxInterfaceError>

Manual

tmux if-shell [-bF] [-t target-pane] shell-command command [command]
(alias: if)

pub fn lock_server(&self) -> Result<Output, TmuxInterfaceError>

Manual

tmux lock-server
(alias: lock)

pub fn run_shell(
    &self,
    backgroud: Option<bool>,
    target_pane: Option<&str>,
    shell_command: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux run-shell [-b] [-t target-pane] shell-command
(alias: run)

pub fn wait_for(
    &self,
    lock: Option<bool>,
    prevent_exit: Option<bool>,
    unlock: Option<bool>,
    channel: &str
) -> Result<Output, TmuxInterfaceError>

Manual

tmux wait-for [-L | -S | -U] channel
(alias: wait)

Trait Implementations

impl<'a> Default for TmuxInterface<'a>

fn default() -> TmuxInterface<'a>

Returns the "default value" for a type.