Struct SplitViewState 

pub struct SplitViewState {

    pub active_buffer: BufferId,
    pub keyed_states: HashMap<BufferId, BufferViewState>,
    pub open_buffers: Vec<TabTarget>,
    pub tab_scroll_offset: usize,
    pub layout: Option<Layout>,
    pub layout_dirty: bool,
    pub focus_history: Vec<TabTarget>,
    pub sync_group: Option<u32>,
    pub composite_view: Option<BufferId>,
    pub suppress_chrome: bool,
    pub hide_tilde: bool,
    pub active_group_tab: Option<LeafId>,
    pub focused_group_leaf: Option<LeafId>,
}

Per-split view state (independent of buffer content)

Following the Emacs model where each window (split) has its own:

• Point (cursor position) - independent per split
• Window-start (scroll position) - independent per split
• Tabs (open buffers) - independent per split

Buffer-specific state (cursors, viewport, view_mode, compose settings) is stored in the keyed_states map, keyed by BufferId. The active buffer’s state is accessible via Deref/DerefMut (so vs.cursors transparently accesses the active buffer’s cursors), or explicitly via active_state()/active_state_mut().

Fields

active_buffer: BufferId

Which buffer is currently active in this split

keyed_states: HashMap<BufferId, BufferViewState>

Per-buffer view state map. The active buffer always has an entry.

open_buffers: Vec<TabTarget>

List of tab targets open in this split’s tab bar (in order). Each entry is either a regular buffer or a grouped subtree. The currently displayed target is tracked by active_buffer (for buffer tabs) or by walking the tree for the active leaf (for group tabs).

tab_scroll_offset: usize

Horizontal scroll offset for the tabs in this split

layout: Option<Layout>

Computed layout for this view (from view_transform or base tokens) This is View state - each split has its own Layout

layout_dirty: bool

Whether the layout needs to be rebuilt (buffer changed, transform changed, etc.)

focus_history: Vec<TabTarget>

Focus history stack for this split (most recent at end). Tracks both buffer tabs and group tabs so that “Switch to Previous Tab” and close-buffer replacement both work across tab types.

sync_group: Option<u32>

Sync group ID for synchronized scrolling Splits with the same sync_group will scroll together

composite_view: Option<BufferId>

When set, this split renders a composite view (e.g., side-by-side diff). The split’s buffer_id is the focused source buffer, but rendering uses the composite layout. This makes the source buffer the “active buffer” so normal keybindings work directly.

suppress_chrome: bool

When true, suppress per-split chrome (tab bar, close/maximize buttons). Used for splits within a buffer group where the group provides its own tab.

hide_tilde: bool

When true, hide tilde markers (~) for empty rows in this split. Used for panels where empty space should be blank, not marked.

active_group_tab: Option<LeafId>

When Some(leaf_id), the currently “active tab” of this split is the buffer group identified by leaf_id (i.e., TabTarget::Group(leaf_id)). When None, the active tab is a regular buffer (TabTarget::Buffer(active_buffer)).

focused_group_leaf: Option<LeafId>

When a group tab is active, this tracks which inner leaf inside the group’s subtree has keyboard focus.

Implementations

impl SplitViewState

pub fn with_buffer(width: u16, height: u16, buffer_id: BufferId) -> Self

Create a new split view state with an initial buffer open

pub fn active_state(&self) -> &BufferViewState

Get the active buffer’s view state

pub fn active_state_mut(&mut self) -> &mut BufferViewState

Get a mutable reference to the active buffer’s view state

pub fn switch_buffer(&mut self, new_buffer_id: BufferId)

Switch the active buffer in this split.

If the new buffer has a saved state in keyed_states, it is restored. Otherwise a default BufferViewState is created with the split’s current viewport dimensions.

pub fn buffer_state(&self, buffer_id: BufferId) -> Option<&BufferViewState>

Get the view state for a specific buffer (if it exists)

pub fn buffer_state_mut( &mut self, buffer_id: BufferId, ) -> Option<&mut BufferViewState>

Get a mutable reference to the view state for a specific buffer (if it exists)

pub fn ensure_buffer_state( &mut self, buffer_id: BufferId, ) -> &mut BufferViewState

Ensure a buffer has keyed state, creating a default if needed. Returns a mutable reference to the buffer’s view state.

pub fn remove_buffer_state(&mut self, buffer_id: BufferId)

Remove keyed state for a buffer (when buffer is closed from this split)

pub fn invalidate_layout(&mut self)

Mark layout as needing rebuild (call after buffer changes)

pub fn ensure_layout( &mut self, tokens: &[ViewTokenWire], source_range: Range<usize>, tab_size: usize, ) -> &Layout

Ensure layout is valid, rebuilding if needed. Returns the Layout - never returns None. Following VSCode’s ViewModel pattern.

Arguments

• tokens - ViewTokenWire array (from view_transform or built from buffer)
• source_range - The byte range this layout covers
• tab_size - Tab width for rendering

pub fn get_layout(&self) -> Option<&Layout>

Get the current layout if it exists and is valid

pub fn add_buffer(&mut self, buffer_id: BufferId)

Add a buffer to this split’s tabs (if not already present)

pub fn remove_buffer(&mut self, buffer_id: BufferId)

Remove a buffer from this split’s tabs and clean up its keyed state

pub fn has_buffer(&self, buffer_id: BufferId) -> bool

Check if a buffer is open in this split

pub fn add_group(&mut self, leaf_id: LeafId)

Add a group tab to this split’s tabs (if not already present)

pub fn remove_group(&mut self, leaf_id: LeafId)

Remove a group tab from this split’s tabs

pub fn has_group(&self, leaf_id: LeafId) -> bool

Check if a group tab is open in this split

pub fn buffer_tab_ids(&self) -> impl Iterator<Item = BufferId> + '_

Iterate over only the buffer-tab ids in open_buffers (skipping groups).

pub fn buffer_tab_ids_vec(&self) -> Vec<BufferId>

Collect buffer-tab ids as a Vec (skipping groups). Convenience for call sites that need ownership / indexing.

pub fn buffer_tab_count(&self) -> usize

Count only buffer tabs (ignoring group tabs).

pub fn active_target(&self) -> TabTarget

Return the effective active tab target for this split. If a group tab is marked active, returns TabTarget::Group. Otherwise returns TabTarget::Buffer(active_buffer).

pub fn set_active_buffer_tab(&mut self, buffer_id: BufferId)

Switch the active tab to a regular buffer target. Clears any active group tab marker.

pub fn set_active_group_tab(&mut self, leaf_id: LeafId)

Switch the active tab to a group target.

pub fn push_focus(&mut self, target: TabTarget)

Push a tab target to the focus history (LRU-style). If the target is already in history, it’s moved to the end.

pub fn previous_tab(&self) -> Option<TabTarget>

Get the most recently focused tab target (without removing it)

pub fn remove_from_history(&mut self, buffer_id: BufferId)

Remove a buffer from the focus history (called when buffer is closed)

pub fn remove_group_from_history(&mut self, leaf_id: LeafId)

Remove a group from the focus history (called when group is closed)

Methods from Deref<Target = BufferViewState>

pub fn ensure_cursor_visible( &mut self, buffer: &mut Buffer, marker_list: &MarkerList, )

Resolve fold ranges and ensure the primary cursor is visible.

This is the preferred entry point for all non-rendering callers — it resolves hidden fold byte ranges from the marker list and passes them to viewport.ensure_visible so that line counting skips folded lines.

pub fn apply_config_defaults( &mut self, line_numbers: bool, highlight_current_line: bool, line_wrap: bool, wrap_indent: bool, wrap_column: Option<usize>, rulers: Vec<usize>, )

Apply editor config defaults for display settings.

Sets show_line_numbers, highlight_current_line, line_wrap, wrap_column, and rulers from the given config values. Call this after creating a new BufferViewState (via new() or ensure_buffer_state()) to ensure the view respects the user’s settings.

pub fn activate_page_view(&mut self, page_width: Option<usize>)

Activate page view (compose mode) with an optional page width.

This sets the view mode to Compose, disables builtin line wrap (the compose plugin handles wrapping), hides line numbers, and optionally sets the compose width for centering.

Trait Implementations

impl Clone for SplitViewState

fn clone(&self) -> SplitViewState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SplitViewState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for SplitViewState

type Target = BufferViewState

The resulting type after dereferencing.

fn deref(&self) -> &BufferViewState

Dereferences the value.

impl DerefMut for SplitViewState

fn deref_mut(&mut self) -> &mut BufferViewState

Mutably dereferences the value.