Struct TerminalState 

pub struct TerminalState { /* private fields */ }

Thread-safe terminal state wrapper.

This struct wraps alacritty’s Term in an Arc<parking_lot::Mutex<>> to allow safe concurrent access from multiple threads. It also manages the VTE parser for processing incoming bytes from the PTY.

Thread Safety

The terminal state can be safely shared across threads:

• Use term_arc to get a cloned Arc for sharing
• Use with_term for read access to the grid
• Use with_term_mut for write access

The mutex is held only for the duration of the closure, minimizing contention.

Grid Access

The terminal grid is accessed through the Term structure:

terminal_state.with_term(|term| {
    let grid = term.grid();
    let cursor = grid.cursor.point;
    let cell = &grid[cursor];
    // Read cell content, colors, flags, etc.
});

Performance Notes

• parking_lot::Mutex is used for faster locking than std::sync::Mutex
• Lock contention is minimized by keeping critical sections short
• The VTE parser state is kept outside the mutex (only accessed from one thread)

Implementations

impl TerminalState

pub fn new(cols: usize, rows: usize, event_proxy: GpuiEventProxy) -> Self

Create a new terminal state with the given dimensions.

Arguments

• cols - The number of columns (character width) of the terminal
• rows - The number of rows (lines) of the terminal
• event_proxy - The event proxy for forwarding terminal events to GPUI

Returns

A new TerminalState instance.

Examples

use std::sync::mpsc::channel;
use gpui_terminal::event::GpuiEventProxy;
use gpui_terminal::terminal::TerminalState;

let (tx, rx) = channel();
let event_proxy = GpuiEventProxy::new(tx);
let terminal = TerminalState::new(80, 24, event_proxy);

pub fn process_bytes(&mut self, bytes: &[u8])

Process incoming bytes from the PTY.

This method feeds the bytes through the VTE parser, which will call the appropriate handler methods on the terminal to update its state.

Arguments

• bytes - The bytes received from the PTY

Examples

// Process some output from the PTY
terminal.process_bytes(b"Hello, world!\r\n");

pub fn resize(&mut self, cols: usize, rows: usize)

Resize the terminal to new dimensions.

This method updates the terminal’s internal grid to match the new size. It should be called when the terminal view is resized.

Arguments

• cols - The new number of columns
• rows - The new number of rows

Examples

// Resize to 120x30
terminal.resize(120, 30);

pub fn mode(&self) -> TermMode

Get the current terminal mode.

The terminal mode affects how certain key sequences are interpreted, particularly arrow keys in application cursor mode.

Returns

The current TermMode flags.

Examples

use alacritty_terminal::term::TermMode;

let mode = terminal.mode();
if mode.contains(TermMode::APP_CURSOR) {
    println!("Application cursor mode is enabled");
}

pub fn with_term<F, R>(&self, f: F) -> R

where F: FnOnce(&Term<GpuiEventProxy>) -> R,

Execute a function with read access to the terminal.

This method provides safe read access to the underlying Term structure. The terminal is locked for the duration of the function call.

Arguments

• f - A function that takes a reference to the Term and returns a value

Returns

The value returned by the function f.

Examples

let cursor_pos = terminal.with_term(|term| {
    term.grid().cursor.point
});

pub fn with_term_mut<F, R>(&self, f: F) -> R

where F: FnOnce(&mut Term<GpuiEventProxy>) -> R,

Execute a function with mutable access to the terminal.

This method provides safe write access to the underlying Term structure. The terminal is locked for the duration of the function call.

Arguments

• f - A function that takes a mutable reference to the Term and returns a value

Returns

The value returned by the function f.

Examples

terminal.with_term_mut(|term| {
    // Perform some mutation on the term
    term.scroll_display(alacritty_terminal::grid::Scroll::Delta(5));
});

pub fn cols(&self) -> usize

Get the number of columns in the terminal.

Returns

The current number of columns.

pub fn rows(&self) -> usize

Get the number of rows in the terminal.

Returns

The current number of rows.

pub fn term_arc(&self) -> Arc<Mutex<Term<GpuiEventProxy>>>

Get a cloned reference to the underlying terminal Arc.

This allows sharing the terminal state across multiple threads or components.

Returns

A cloned Arc<Mutex<Term<GpuiEventProxy>>>.