Struct DisplayMap 

pub struct DisplayMap { /* private fields */ }

DisplayMap is the main interface for Editor/Input coordinate mapping.

It manages the two-layer projection:

1. Buffer → Wrap (soft-wrapping)
2. Wrap → Display (folding)

Editor/Input only needs to work with BufferPoint and DisplayPoint.

Implementations

impl DisplayMap

pub fn new(font: Font, font_size: Pixels, wrap_width: Option<Pixels>) -> Self

pub fn buffer_pos_to_display_pos(&self, pos: BufferPoint) -> DisplayPoint

Convert buffer position to display position

pub fn display_pos_to_buffer_pos(&self, pos: DisplayPoint) -> BufferPoint

Convert display position to buffer position

pub fn display_row_count(&self) -> usize

Get total number of visible display rows

pub fn display_row_to_buffer_line(&self, display_row: usize) -> usize

Get the buffer line for a given display row

pub fn buffer_line_to_display_row_range( &self, line: usize, ) -> Option<Range<usize>>

Get the display row range for a buffer line: [start, end) Returns None if the buffer line is completely hidden

pub fn is_buffer_line_hidden(&self, line: usize) -> bool

Check if a buffer line is completely hidden

pub fn buffer_line_to_display_row(&self, line: usize) -> usize

First display row of a buffer line. If the line is fully folded, returns the nearest visible display row.

pub fn set_fold_candidates(&mut self, candidates: Vec<FoldRange>)

Set fold candidates (from tree-sitter/LSP)

pub fn set_folded(&mut self, start_line: usize, folded: bool)

Set a fold at the given start_line (must be in candidates)

pub fn toggle_fold(&mut self, start_line: usize)

Toggle fold at the given start_line

pub fn is_folded_at(&self, start_line: usize) -> bool

Check if a line is currently folded

pub fn is_fold_candidate(&self, start_line: usize) -> bool

Check if a line is a fold candidate

pub fn folded_ranges(&self) -> &[FoldRange]

Get all currently folded ranges

pub fn clear_folds(&mut self)

Clear all folds

pub fn adjust_folds_for_edit( &mut self, old_text: &Rope, range: &Range<usize>, new_text: &str, )

Adjust folds and candidates for a text edit before updating the wrap map.

Must be called with the OLD text (before replacement) and the edit range/new_text so we can compute which old lines were affected.

pub fn update_fold_candidates_for_edit( &mut self, extract_fold_ranges: impl FnOnce(Range<usize>, &Rope) -> Vec<FoldRange>, edit_byte_range: Range<usize>, new_text: &Rope, )

Incrementally update fold candidates after a text edit.

Extracts new fold candidates only within the edited byte range and merges them with existing (already adjusted) candidates.

pub fn on_text_changed( &mut self, changed_text: &Rope, range: &Range<usize>, new_text: &Rope, cx: &mut App, )

Update text (incremental or full)

pub fn on_layout_changed(&mut self, wrap_width: Option<Pixels>, cx: &mut App)

Update layout parameters (wrap width or font)

pub fn set_wrapping_indent( &mut self, wrapping_indent: WrappingIndent, cx: &mut App, )

Set the wrapping indent for continuation lines.

pub fn set_font(&mut self, font: Font, font_size: Pixels, cx: &mut App)

Set font parameters

pub fn ensure_text_prepared(&mut self, text: &Rope, cx: &mut App)

Ensure text is prepared (initializes wrapper if needed)

pub fn set_text(&mut self, text: &Rope, cx: &mut App)

Initialize with text

pub fn wrap_row_to_display_row(&self, wrap_row: usize) -> Option<usize>

Convert a wrap row to a display row (skipping folded rows). Returns None if the wrap row is folded.

pub fn nearest_visible_display_row(&self, wrap_row: usize) -> usize

Find the nearest visible display row for a given wrap row.

pub fn display_row_to_wrap_row(&self, display_row: usize) -> Option<usize>

Convert a display row to a wrap row.

pub fn text(&self) -> &Rope

Get the rope text

pub fn visible_wrap_row_count_for_buffer_line(&self, line: usize) -> usize

Calculate how many wrap rows of a buffer line are visible (not folded)

pub fn wrap_row_count(&self) -> usize

Get the wrap row count (before folding)

pub fn buffer_line_count(&self) -> usize

Get the buffer line count (logical lines)