Struct EditorState 

pub struct EditorState {

    pub buffer: Buffer,
    pub highlighter: HighlightEngine,
    pub indent_calculator: RefCell<IndentCalculator>,
    pub overlays: OverlayManager,
    pub marker_list: MarkerList,
    pub virtual_texts: VirtualTextManager,
    pub conceals: ConcealManager,
    pub soft_breaks: SoftBreakManager,
    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 buffer_settings: BufferSettings,
    pub reference_highlighter: ReferenceHighlighter,
    pub is_composite_buffer: bool,
    pub debug_highlight_mode: bool,
    pub reference_highlight_overlay: ReferenceHighlightOverlay,
    pub bracket_highlight_overlay: BracketHighlightOverlay,
    pub semantic_tokens: Option<SemanticTokenStore>,
    pub folding_ranges: Vec<FoldingRange>,
    pub language: String,
    pub display_name: 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

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.)

conceals: ConcealManager

Conceal ranges for hiding/replacing byte ranges during rendering

soft_breaks: SoftBreakManager

Soft break points for marker-based line wrapping during rendering

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

buffer_settings: BufferSettings

Per-buffer user settings (tab size, indentation style, etc.) These settings are preserved across file reloads (auto-revert)

reference_highlighter: ReferenceHighlighter

Semantic highlighter for word occurrence highlighting

is_composite_buffer: bool

Whether this buffer is a composite view (e.g., side-by-side diff)

debug_highlight_mode: bool

Debug mode: reveal highlight/overlay spans (WordPerfect-style)

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)

folding_ranges: Vec<FoldingRange>

Last-known LSP folding ranges for this buffer

language: String

The detected language ID for this buffer (e.g., “rust”, “csharp”, “text”). Used for LSP config lookup and internal identification.

display_name: String

Human-readable language display name (e.g., “Rust”, “C#”, “Plain Text”). Shown in the status bar and Set Language prompt.

Implementations

impl EditorState

pub fn apply_language(&mut self, detected: DetectedLanguage)

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. Apply a detected language to this state. This is the single mutation point for changing the language of a buffer after creation.

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

pub fn new_with_path( large_file_threshold: usize, fs: Arc<dyn FileSystem + Send + Sync>, path: PathBuf, ) -> Self

Create a new editor state with an empty buffer associated with a file path. Used for files that don’t exist yet — the path is set so saving will create the file.

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

Set the syntax highlighting language based on a virtual buffer name. Handles names like *OLD:test.ts* or *OURS*.c by stripping markers and detecting language from the cleaned filename.

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 from_buffer_with_language( buffer: Buffer, detected: DetectedLanguage, ) -> Self

Create an editor state from a buffer and a pre-built DetectedLanguage.

This is useful when you have already loaded a buffer with a specific encoding and want to create an EditorState from it.

pub fn apply(&mut self, cursors: &mut Cursors, 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 capture_displaced_markers( &self, range: &Range<usize>, ) -> Vec<(u64, usize)>

Capture positions of markers strictly inside a deleted range. Call this BEFORE applying the delete. Returns encoded displaced markers.

pub fn capture_displaced_markers_bulk( &self, edits: &[(usize, usize, String)], ) -> Vec<(u64, usize)>

Capture displaced markers for multiple delete ranges (BulkEdit).

pub fn restore_displaced_markers(&mut self, displaced: &[(u64, usize)])

Restore displaced markers to their exact original positions.

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

Apply multiple events in sequence

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