Rust API

window.Window.set_hooks

Rust

Python
TypeScript Unavailable
Rust
Go
Java Unavailable
.NET Unavailable
C++ Unavailable
Swift Unavailable

Module: window
Declared in: Window
Package: libtmux
Source: crates/libtmux/src/window/settings.rs
Other languages: Python TypeScript Go Java .NET C++ Swift

set_hooks ( self , name : &str , hooks : &IndexedHooks , replace : ReplaceMode ) → Result<(), Error> method [source] ¶ method [source] ¶ set_hooks

Write a whole hook at once.

ReplaceMode::Replace clears the hook first, so only what is written remains; ReplaceMode::Merge leaves entries at indices the write does not name.

Sent as at most two tmux invocations rather than one per index: the first command alone, then the rest together. That is not atomic: tmux applies a shared invocation in order and stops at the first refusal, so a rejected entry leaves the ones before it written.

Errors

Returns an error when tmux rejects the name or any command.

Returns crate::Error::OptionScopeMismatch when tmux keeps the option in another of its tables.

Cancel safety

Under ReplaceMode::Replace the clear and the entries are one invocation, so a drop leaves the hook as it was or fully written, never cleared and unwritten; tmux reports one status for that group, so a refusal there cannot name which command drew it. Under ReplaceMode::Merge the first entry is sent on its own, so a drop after it leaves that entry written and the rest not.

In other ports Write a window hook and its indexed commands at once

Python libtmux.Window.set_hooks
TypeScript no equivalent on Window
Go tmux.Window.SetHooks
Java no equivalent on Window
.NET no equivalent on Window
C++ no equivalent on Window
Swift no equivalent on Window

Examples

Rust Python

use std::collections::BTreeMap;
use libtmux::{IndexedHooks, ReplaceMode, TmuxText};

let guard = libtmux::test::TestServer::new().await?;
let session = guard.server().new_session("hooked").await?;
let window = session.active_window().await?.expect("a window");

let mut entries = BTreeMap::new();
entries.insert(0, TmuxText::from(b"display-message first".to_vec()));
entries.insert(3, TmuxText::from(b"display-message fourth".to_vec()));

window
    .set_hooks("pane-died", &IndexedHooks::from(entries), ReplaceMode::Replace)
    .await?;

let written = window.hook("pane-died").await?.expect("the hook is set");
assert_eq!(written.len(), 2);
assert!(written.get(1).is_none(), "the gap is kept");

guard.shutdown().await?;

Set hooks with explicit indices:

>>> session.set_hooks('session-renamed', {
...     0: 'display-message "hook 0"',
...     1: 'display-message "hook 1"',
... })
Session($...)

>>> hooks = session.show_hook('session-renamed')
>>> sorted(hooks.keys())
[0, 1]

>>> session.unset_hook('session-renamed')
Session($...)

Set hooks from a list (sequential indices):

>>> session.set_hooks('after-new-window', [
...     'select-pane -t 0',
...     'send-keys "clear" Enter',
... ])
Session($...)

>>> hooks = session.show_hook('after-new-window')
>>> sorted(hooks.keys())
[0, 1]

Replace all existing hooks with clear_existing=True:

>>> session.set_hooks(
...     'session-renamed',
...     {0: 'display-message "new"'},
...     clear_existing=True,
... )
Session($...)

>>> hooks = session.show_hook('session-renamed')
>>> sorted(hooks.keys())
[0]

>>> session.unset_hook('session-renamed')
Session($...)

>>> session.unset_hook('after-new-window')
Session($...)

0 declared, 0 inherited