Struct Pane 

pub struct Pane {

    pub id: PaneId,
    pub terminal: Arc<RwLock<TerminalManager>>,
    pub scroll_state: ScrollState,
    pub mouse: MouseState,
    pub bell: BellState,
    pub cache: RenderCache,
    pub refresh_task: Option<JoinHandle<()>>,
    pub working_directory: Option<String>,
    pub last_activity_time: Instant,
    pub last_seen_generation: u64,
    pub anti_idle_last_activity: Instant,
    pub anti_idle_last_generation: u64,
    pub silence_notified: bool,
    pub exit_notified: bool,
    pub session_logger: SharedSessionLogger,
    pub bounds: PaneBounds,
    pub background: PaneBackground,
    pub title: String,
    pub has_default_title: bool,
    pub restart_state: Option<RestartState>,
    pub is_active: Arc<AtomicBool>,
    /* private fields */
}

A single terminal pane with its own state

RwLock Strategy

terminal uses tokio::sync::RwLock for the same reason as Tab::terminal: TerminalManager is shared between the async PTY reader task and the sync winit event loop.

Access rules:

• From async tasks: terminal.read().await or terminal.write().await
• From the sync event loop: terminal.try_read() or terminal.try_write() for polling; terminal.blocking_write() for infrequent user-initiated operations only.

Fields

id: PaneId

Unique identifier for this pane

terminal: Arc<RwLock<TerminalManager>>

The terminal session for this pane.

Uses tokio::sync::RwLock. From sync contexts use .try_read() or .try_write() for non-blocking access or .blocking_write() for user-initiated operations.

scroll_state: ScrollState

Scroll state for this pane

mouse: MouseState

Mouse state for this pane

bell: BellState

Bell state for this pane

cache: RenderCache

Render cache for this pane

refresh_task: Option<JoinHandle<()>>

Async task for refresh polling

working_directory: Option<String>

Working directory when pane was created

last_activity_time: Instant

Last time terminal output (activity) was detected

last_seen_generation: u64

Last terminal update generation seen

anti_idle_last_activity: Instant

Last activity time for anti-idle keep-alive

anti_idle_last_generation: u64

Last terminal generation recorded for anti-idle tracking

silence_notified: bool

Whether silence notification has been sent for current idle period

exit_notified: bool

Whether exit notification has been sent for this pane

session_logger: SharedSessionLogger

Session logger for automatic session recording

bounds: PaneBounds

Current bounds of this pane (updated on layout calculation)

background: PaneBackground

Per-pane background settings (overrides global config if image_path is set)

title: String

Last-known title from OSC sequences or CWD fallback (empty if never set)

has_default_title: bool

True when pane still has its default/fallback title

restart_state: Option<RestartState>

State for shell restart behavior (None = shell running or closed normally)

is_active: Arc<AtomicBool>

Whether the parent tab is active (shared with tab for refresh throttling)

Implementations

impl Pane

pub fn new( id: PaneId, config: &Config, _runtime: Arc<Runtime>, working_directory: Option<String>, ) -> Result<Self>

Create a new pane with a terminal session

pub fn new_with_command( id: PaneId, config: &Config, _runtime: Arc<Runtime>, working_directory: Option<String>, command: String, args: Vec<String>, ) -> Result<Self>

Create a pane that launches command args instead of the configured login shell.

Identical to Pane::new() except the PTY is started with the given command. All other fields (scroll state, cache, refresh task, etc.) are the same as new().

pub fn new_wrapping_terminal( id: PaneId, terminal: Arc<RwLock<TerminalManager>>, working_directory: Option<String>, is_active: Arc<AtomicBool>, ) -> Self

Create a primary pane that wraps an already-running terminal session.

Unlike Pane::new, this constructor does not spawn a new shell. It shares the caller’s Arc<RwLock<TerminalManager>> directly, so the pane’s terminal is the same session that Tab::terminal points to.

Used by Tab::new_internal to always initialise a PaneManager with a single primary pane at tab creation, removing the need for tab-level scroll_state, mouse, bell, and cache fallback fields (R-32).

Arguments

• id — Pane identifier (typically 1)
• terminal — Shared Arc cloned from the owning Tab::terminal
• working_directory — Optional CWD exposed via Pane::get_cwd
• is_active — Shared atomic flag cloned from the owning Tab::is_active

pub fn new_for_tmux( id: PaneId, config: &Config, _runtime: Arc<Runtime>, ) -> Result<Self>

Create a new pane for tmux integration (no shell spawned)

This creates a terminal that receives output from tmux control mode rather than a local PTY.

pub fn is_bell_active(&self) -> bool

Check if the visual bell is currently active

pub fn is_running(&self) -> bool

Check if the terminal in this pane is still running

pub fn get_cwd(&self) -> Option<String>

Get the current working directory of this pane’s shell

pub fn set_background(&mut self, background: PaneBackground)

Set per-pane background settings (overrides global config)

pub fn background(&self) -> &PaneBackground

Get per-pane background settings

pub fn set_background_image(&mut self, path: Option<String>)

Set a per-pane background image (overrides global config)

pub fn get_background_image(&self) -> Option<&str>

Get the per-pane background image path (if set)

impl Pane

pub fn respawn_shell(&mut self, config: &Config) -> Result<()>

Respawn the shell in this pane

This resets the terminal state and spawns a new shell process. Used when shell_exit_action is one of the restart variants.

pub fn write_restart_prompt(&self)

Write a restart prompt message to the terminal

pub fn get_title(&self) -> String

Get the title for this pane (from OSC or CWD)

pub fn start_refresh_task( &mut self, runtime: Arc<Runtime>, window: Arc<Window>, active_fps: u32, inactive_fps: u32, )

Start the refresh polling task for this pane

pub fn stop_refresh_task(&mut self)

Stop the refresh polling task

pub fn resize_terminal(&self, cols: usize, rows: usize)

Resize the terminal to match the pane bounds

pub fn resize_terminal_with_cell_dims( &self, cols: usize, rows: usize, cell_width: u32, cell_height: u32, )

Resize the terminal and update cell pixel dimensions.

Unlike resize_terminal, this also calls set_cell_dimensions so that the core library tracks scroll_offset_rows in display-cell units rather than its internal default (2 px per row). Must be called whenever the display cell size is known (e.g., on every layout pass).

Trait Implementations

impl Drop for Pane

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.