Struct Tui 

pub struct Tui { /* private fields */ }

Main TUI handle that integrates with the event bus.

Implementations

impl Tui

pub fn new() -> Self

Creates a new TUI instance with shared state.

Examples found in repository

examples/pty_output_demo.rs (line 66)

async fn main() -> anyhow::Result<()> {
    // Spawn ls -la command
    let mut child = Command::new("ls")
        .arg("-la")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;

    let stdout = child.stdout.take().expect("Failed to capture stdout");
    let stderr = child.stderr.take().expect("Failed to capture stderr");

    // Create channels for PTY handle
    let (output_tx, output_rx) = mpsc::unbounded_channel();
    let (input_tx, _input_rx) = mpsc::unbounded_channel();
    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    let (_terminated_tx, terminated_rx) = watch::channel(false);

    // Clone output_tx before moving it
    let output_tx_clone = output_tx.clone();

    // Spawn task to read stdout and send to output channel
    tokio::spawn(async move {
        let mut stdout = stdout;
        let mut buf = vec![0u8; 1024];
        while let Ok(n) = stdout.read(&mut buf).await {
            if n == 0 {
                break;
            }
            let _ = output_tx.send(buf[..n].to_vec());
        }
    });

    // Spawn task to read stderr and send to output channel
    tokio::spawn(async move {
        let mut stderr = stderr;
        let mut buf = vec![0u8; 1024];
        while let Ok(n) = stderr.read(&mut buf).await {
            if n == 0 {
                break;
            }
            let _ = output_tx_clone.send(buf[..n].to_vec());
        }
    });

    // Create PTY handle
    let pty_handle = PtyHandle {
        output_rx,
        input_tx,
        control_tx,
        terminated_rx,
    };

    // Create TUI with PTY handle
    let tui = Tui::new().with_pty(pty_handle);

    // Run TUI (will exit on Ctrl+C)
    tui.run().await?;

    // Wait for command to finish
    let _ = child.wait().await;

    Ok(())
}

pub fn with_prefix( self, prefix_key: KeyCode, prefix_modifiers: KeyModifiers, ) -> Self

Sets custom prefix key.

pub fn with_pty(self, pty_handle: PtyHandle) -> Self

Sets the PTY handle for terminal output.

Examples found in repository

examples/pty_output_demo.rs (line 66)

async fn main() -> anyhow::Result<()> {
    // Spawn ls -la command
    let mut child = Command::new("ls")
        .arg("-la")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;

    let stdout = child.stdout.take().expect("Failed to capture stdout");
    let stderr = child.stderr.take().expect("Failed to capture stderr");

    // Create channels for PTY handle
    let (output_tx, output_rx) = mpsc::unbounded_channel();
    let (input_tx, _input_rx) = mpsc::unbounded_channel();
    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    let (_terminated_tx, terminated_rx) = watch::channel(false);

    // Clone output_tx before moving it
    let output_tx_clone = output_tx.clone();

    // Spawn task to read stdout and send to output channel
    tokio::spawn(async move {
        let mut stdout = stdout;
        let mut buf = vec![0u8; 1024];
        while let Ok(n) = stdout.read(&mut buf).await {
            if n == 0 {
                break;
            }
            let _ = output_tx.send(buf[..n].to_vec());
        }
    });

    // Spawn task to read stderr and send to output channel
    tokio::spawn(async move {
        let mut stderr = stderr;
        let mut buf = vec![0u8; 1024];
        while let Ok(n) = stderr.read(&mut buf).await {
            if n == 0 {
                break;
            }
            let _ = output_tx_clone.send(buf[..n].to_vec());
        }
    });

    // Create PTY handle
    let pty_handle = PtyHandle {
        output_rx,
        input_tx,
        control_tx,
        terminated_rx,
    };

    // Create TUI with PTY handle
    let tui = Tui::new().with_pty(pty_handle);

    // Run TUI (will exit on Ctrl+C)
    tui.run().await?;

    // Wait for command to finish
    let _ = child.wait().await;

    Ok(())
}

pub fn with_hat_map(self, hat_map: HashMap<String, (HatId, String)>) -> Self

Sets the hat map for dynamic topic-to-hat resolution.

This allows the TUI to display the correct hat for custom topics without hardcoding them in TuiState::update().

pub fn observer(&self) -> impl Fn(&Event) + Send + 'static

Returns an observer closure that updates TUI state from events.

pub async fn run(self) -> Result<()>

Runs the TUI application loop.

Panics

Panics if with_pty() was not called before running.

Errors

Returns an error if the terminal cannot be initialized or if the application loop encounters an unrecoverable error.

Examples found in repository

examples/pty_output_demo.rs (line 69)

async fn main() -> anyhow::Result<()> {
    // Spawn ls -la command
    let mut child = Command::new("ls")
        .arg("-la")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;

    let stdout = child.stdout.take().expect("Failed to capture stdout");
    let stderr = child.stderr.take().expect("Failed to capture stderr");

    // Create channels for PTY handle
    let (output_tx, output_rx) = mpsc::unbounded_channel();
    let (input_tx, _input_rx) = mpsc::unbounded_channel();
    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    let (_terminated_tx, terminated_rx) = watch::channel(false);

    // Clone output_tx before moving it
    let output_tx_clone = output_tx.clone();

    // Spawn task to read stdout and send to output channel
    tokio::spawn(async move {
        let mut stdout = stdout;
        let mut buf = vec![0u8; 1024];
        while let Ok(n) = stdout.read(&mut buf).await {
            if n == 0 {
                break;
            }
            let _ = output_tx.send(buf[..n].to_vec());
        }
    });

    // Spawn task to read stderr and send to output channel
    tokio::spawn(async move {
        let mut stderr = stderr;
        let mut buf = vec![0u8; 1024];
        while let Ok(n) = stderr.read(&mut buf).await {
            if n == 0 {
                break;
            }
            let _ = output_tx_clone.send(buf[..n].to_vec());
        }
    });

    // Create PTY handle
    let pty_handle = PtyHandle {
        output_rx,
        input_tx,
        control_tx,
        terminated_rx,
    };

    // Create TUI with PTY handle
    let tui = Tui::new().with_pty(pty_handle);

    // Run TUI (will exit on Ctrl+C)
    tui.run().await?;

    // Wait for command to finish
    let _ = child.wait().await;

    Ok(())
}

Trait Implementations

impl Default for Tui

fn default() -> Self

Returns the “default value” for a type.