Struct EditorState 

pub struct EditorState {

    pub buffer: Buffer,
    pub cursors: Cursors,
    pub highlighter: HighlightEngine,
    pub indent_calculator: RefCell<IndentCalculator>,
    pub overlays: OverlayManager,
    pub marker_list: MarkerList,
    pub virtual_texts: VirtualTextManager,
    pub popups: PopupManager,
    pub margins: MarginManager,
    pub primary_cursor_line_number: LineNumber,
    pub mode: String,
    pub text_properties: TextPropertyManager,
    pub show_cursors: bool,
    pub editing_disabled: bool,
    pub is_composite_buffer: bool,
    pub show_whitespace_tabs: bool,
    pub use_tabs: bool,
    pub tab_size: usize,
    pub reference_highlighter: ReferenceHighlighter,
    pub view_mode: ViewMode,
    pub debug_highlight_mode: bool,
    pub compose_width: Option<u16>,
    pub compose_prev_line_numbers: Option<bool>,
    pub compose_column_guides: Option<Vec<u16>>,
    pub view_transform: Option<ViewTransformPayload>,
    pub reference_highlight_overlay: ReferenceHighlightOverlay,
    pub bracket_highlight_overlay: BracketHighlightOverlay,
    pub semantic_tokens: Option<SemanticTokenStore>,
    pub language: String,
}

The complete editor state - everything needed to represent the current editing session

NOTE: Viewport is NOT stored here - it lives in SplitViewState. This is because viewport is view-specific (each split can view the same buffer at different scroll positions), while EditorState represents the buffer content.

Fields

buffer: Buffer

The text buffer

cursors: Cursors

All cursors

highlighter: HighlightEngine

Syntax highlighter (tree-sitter or TextMate based on language)

indent_calculator: RefCell<IndentCalculator>

Auto-indent calculator for smart indentation (RefCell for interior mutability)

overlays: OverlayManager

Overlays for visual decorations (underlines, highlights, etc.)

marker_list: MarkerList

Marker list for content-anchored overlay positions

virtual_texts: VirtualTextManager

Virtual text manager for inline hints (type hints, parameter hints, etc.)

popups: PopupManager

Popups for floating windows (completion, documentation, etc.)

margins: MarginManager

Margins for line numbers, annotations, gutter symbols, etc.)

primary_cursor_line_number: LineNumber

Cached line number for primary cursor (0-indexed) Maintained incrementally to avoid O(n) scanning on every render

mode: String

Current mode (for modal editing, if implemented)

text_properties: TextPropertyManager

Text properties for virtual buffers (embedded metadata in text ranges) Used by virtual buffers to store location info, severity, etc.

show_cursors: bool

Whether to show cursors in this buffer (default true) Can be set to false for virtual buffers like diagnostics panels

editing_disabled: bool

Whether editing is disabled for this buffer (default false) When true, typing, deletion, cut/paste, undo/redo are blocked but navigation, selection, and copy are still allowed

is_composite_buffer: bool

Whether this buffer is a composite buffer (multi-pane view) When true, the buffer content is rendered by the composite renderer instead of the normal buffer rendering path

show_whitespace_tabs: bool

Whether to show whitespace tab indicators (→) for this buffer Set based on language config; defaults to true

use_tabs: bool

Whether pressing Tab should insert a tab character instead of spaces. Set based on language config; defaults to false (insert spaces).

tab_size: usize

Tab size (number of spaces per tab character) for rendering. Used for visual display of tab characters and indent calculations.

reference_highlighter: ReferenceHighlighter

Semantic highlighter for word occurrence highlighting

view_mode: ViewMode

View mode for this buffer (Source or Compose)

debug_highlight_mode: bool

Debug mode: show highlight/overlay byte ranges When enabled, each character shows its byte position and highlight info

compose_width: Option<u16>

Optional compose width for centered rendering

compose_prev_line_numbers: Option<bool>

Previously configured line number visibility (to restore after Compose)

compose_column_guides: Option<Vec<u16>>

Optional column guides (e.g., for tables) supplied by layout hints

view_transform: Option<ViewTransformPayload>

Optional transformed view payload for current viewport (tokens + map)

reference_highlight_overlay: ReferenceHighlightOverlay

Debounced semantic highlight cache

bracket_highlight_overlay: BracketHighlightOverlay

Bracket matching highlight overlay

semantic_tokens: Option<SemanticTokenStore>

Cached LSP semantic tokens (converted to buffer byte ranges)

language: String

The detected language for this buffer (e.g., “rust”, “python”, “text”)

Implementations

impl EditorState

pub fn new( _width: u16, _height: u16, large_file_threshold: usize, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Self

Create a new editor state with an empty buffer

Note: width/height parameters are kept for backward compatibility but are no longer used - viewport is now owned by SplitViewState.

pub fn set_language_from_name(&mut self, name: &str, registry: &GrammarRegistry)

Set the syntax highlighting language based on a filename or extension This allows virtual buffers to get highlighting even without a real file path

pub fn from_file( path: &Path, _width: u16, _height: u16, large_file_threshold: usize, registry: &GrammarRegistry, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Result<Self>

Create an editor state from a file

Note: width/height parameters are kept for backward compatibility but are no longer used - viewport is now owned by SplitViewState.

pub fn from_file_with_languages( path: &Path, _width: u16, _height: u16, large_file_threshold: usize, registry: &GrammarRegistry, languages: &HashMap<String, LanguageConfig>, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Result<Self>

Create an editor state from a file with language configuration.

This version uses the provided languages configuration for syntax detection, allowing user-configured filename patterns to be respected for highlighting.

Note: width/height parameters are kept for backward compatibility but are no longer used - viewport is now owned by SplitViewState.

pub fn apply(&mut self, event: &Event)

Apply an event to the state - THE ONLY WAY TO MODIFY STATE This is the heart of the event-driven architecture

pub fn apply_many(&mut self, events: &[Event])

Apply multiple events in sequence

pub fn primary_cursor(&self) -> &Cursor

Get the primary cursor

pub fn primary_cursor_mut(&mut self) -> &mut Cursor

Get the primary cursor mutably (for reading state only, not for modification!)

pub fn on_focus_lost(&mut self)

Called when this buffer loses focus (e.g., switching to another buffer, opening a prompt, focusing file explorer, etc.) Dismisses transient popups like Hover and Signature Help.

impl EditorState

pub fn prepare_for_render(&mut self, top_byte: usize, height: u16) -> Result<()>

Prepare viewport for rendering (called before frame render)

This pre-loads all data that will be needed for rendering the current viewport, ensuring that subsequent read-only access during rendering will succeed.

Takes viewport parameters since viewport is now owned by SplitViewState.

pub fn get_text_range(&mut self, start: usize, end: usize) -> String

Get text in a range, driving lazy loading transparently

This is a convenience wrapper around DocumentModel::get_range that:

• Drives lazy loading automatically (never fails due to unloaded data)
• Uses byte offsets directly
• Returns String (not Result) - errors are logged internally
• Returns empty string for invalid ranges

This is the preferred API for getting text ranges. The caller never needs to worry about lazy loading or buffer preparation.

Example

let text = state.get_text_range(0, 100);

pub fn get_line_at_offset(&mut self, offset: usize) -> Option<(usize, String)>

Get the content of a line by its byte offset

Returns the line containing the given offset, along with its start position. This uses DocumentModel’s viewport functionality for consistent behavior.

Returns

Some((line_start_offset, line_content)) if successful, None if offset is invalid

pub fn get_text_to_end_of_line(&mut self, cursor_pos: usize) -> Result<String>

Get text from current cursor position to end of line

This is a common pattern in editing operations. Uses DocumentModel for consistent behavior across file sizes.

pub fn set_semantic_tokens(&mut self, store: SemanticTokenStore)

Replace cached semantic tokens with a new store.

pub fn clear_semantic_tokens(&mut self)

Clear cached semantic tokens (e.g., when tokens are invalidated).

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

Get the server-provided semantic token result_id if available.

Trait Implementations

impl DocumentModel for EditorState

Implement DocumentModel trait for EditorState

This provides a clean abstraction layer between rendering/editing operations and the underlying text buffer implementation.

fn capabilities(&self) -> DocumentCapabilities

Get document capabilities

fn get_viewport_content( &mut self, start_pos: DocumentPosition, max_lines: usize, ) -> Result<ViewportContent>

Get content at a viewport (the core rendering primitive)

fn position_to_offset(&self, pos: DocumentPosition) -> Result<usize>

Convert position to byte offset (always works)

fn offset_to_position(&self, offset: usize) -> DocumentPosition

Convert byte offset to a position

fn get_range( &mut self, start: DocumentPosition, end: DocumentPosition, ) -> Result<String>

Get a range of text by positions May trigger lazy loading for large files

fn get_line_content(&mut self, line_number: usize) -> Option<String>

Get a single line if line indexing is available

fn get_chunk_at_offset( &mut self, offset: usize, size: usize, ) -> Result<(usize, String)>

Get text around a byte offset (for operations that don’t need exact lines)

fn insert(&mut self, pos: DocumentPosition, text: &str) -> Result<usize>

Insert text at a position

fn delete( &mut self, start: DocumentPosition, end: DocumentPosition, ) -> Result<()>

Delete a range

fn replace( &mut self, start: DocumentPosition, end: DocumentPosition, text: &str, ) -> Result<()>

Replace a range

fn find_matches( &mut self, pattern: &str, search_range: Option<(DocumentPosition, DocumentPosition)>, ) -> Result<Vec<usize>>

Find all matches of a pattern in a range

fn has_line_index(&self) -> bool

Check if line indexing is available