Struct SplitViewState 

pub struct SplitViewState {
    pub active_buffer: BufferId,
    pub keyed_states: HashMap<BufferId, BufferViewState>,
    pub open_buffers: Vec<BufferId>,
    pub tab_scroll_offset: usize,
    pub layout: Option<Layout>,
    pub layout_dirty: bool,
    pub focus_history: Vec<BufferId>,
    pub sync_group: Option<u32>,
    pub composite_view: Option<BufferId>,
}

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<BufferId>

List of buffer IDs open in this split’s tab bar (in order) The currently displayed buffer is tracked in the SplitNode::Leaf

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<BufferId>

Focus history stack for this split (most recent at end) Used for “Switch to Previous Tab” and for returning to previous buffer when closing

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.

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 push_focus(&mut self, buffer_id: BufferId)

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

pub fn previous_buffer(&self) -> Option<BufferId>

Get the most recently focused buffer (without removing it)

pub fn pop_focus(&mut self) -> Option<BufferId>

Pop the most recent buffer from focus history

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

Remove a buffer from the focus history (called when buffer 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, line_wrap: bool, wrap_indent: bool, rulers: Vec<usize>, )

Apply editor config defaults for display settings.

Sets show_line_numbers, line_wrap, 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.

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.