//! This module defines where the text should be displayed in an [`Editor`][Editor].//!//! Not literally though - rendering, layout and all that jazz is a responsibility of [`EditorElement`][EditorElement].//! Instead, [`DisplayMap`] decides where Inlays/Inlay hints are displayed, when//! to apply a soft wrap, where to add fold indicators, whether there are any tabs in the buffer that//! we display as spaces and where to display custom blocks (like diagnostics).//! Seems like a lot? That's because it is. [`DisplayMap`] is conceptually made up//! of several smaller structures that form a hierarchy (starting at the bottom)://! - [`InlayMap`] that decides where the [`Inlay`]s should be displayed.//! - [`FoldMap`] that decides where the fold indicators should be; it also tracks parts of a source file that are currently folded.//! - [`CharMap`] that replaces tabs and non-printable characters//! - [`WrapMap`] that handles soft wrapping.//! - [`BlockMap`] that tracks custom blocks such as diagnostics that should be displayed within buffer.//! - [`DisplayMap`] that adds background highlights to the regions of text.//!   Each one of those builds on top of preceding map.//!//! [Editor]: crate::Editor//! [EditorElement]: crate::element::EditorElement mod block_map;mod char_map;mod crease_map;mod fold_map;mod inlay_map;mod invisibles;mod wrap_map; use crate::{    hover_links::InlayHighlight, movement::TextLayoutDetails, EditorStyle, InlayId, RowExt,};pub use block_map::{    Block, BlockBufferRows, BlockChunks as DisplayChunks, BlockContext, BlockId, BlockMap,    BlockPlacement, BlockPoint, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,};use block_map::{BlockRow, BlockSnapshot};use char_map::{CharMap, CharSnapshot};use collections::{HashMap, HashSet};pub use crease_map::*;pub use fold_map::{Fold, FoldId, FoldPlaceholder, FoldPoint};use fold_map::{FoldMap, FoldSnapshot};use gpui::{    AnyElement, Font, HighlightStyle, LineLayout, Model, ModelContext, Pixels, UnderlineStyle,};pub(crate) use inlay_map::Inlay;use inlay_map::{InlayMap, InlaySnapshot};pub use inlay_map::{InlayOffset, InlayPoint};pub use invisibles::is_invisible;use language::{    language_settings::language_settings, ChunkRenderer, OffsetUtf16, Point,    Subscription as BufferSubscription,};use lsp::DiagnosticSeverity;use multi_buffer::{    Anchor, AnchorRangeExt, MultiBuffer, MultiBufferPoint, MultiBufferRow, MultiBufferSnapshot,    ToOffset, ToPoint,};use serde::Deserialize;use std::{    any::TypeId,    borrow::Cow,    fmt::Debug,    num::NonZeroU32,    ops::{Add, Range, Sub},    sync::Arc,};use sum_tree::{Bias, TreeMap};use text::LineIndent;use ui::{px, WindowContext};use unicode_segmentation::UnicodeSegmentation;use wrap_map::{WrapMap, WrapSnapshot}; #[derive(Copy, Clone, Debug, PartialEq, Eq)]pub enum FoldStatus {    Folded,    Foldable,} pub type RenderFoldToggle = Arc<dyn Fn(FoldStatus, &mut WindowContext) -> AnyElement>; pub trait ToDisplayPoint {    fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint;} type TextHighlights = TreeMap<Option<TypeId>, Arc<(HighlightStyle, Vec<Range<Anchor>>)>>;type InlayHighlights = TreeMap<TypeId, TreeMap<InlayId, (HighlightStyle, InlayHighlight)>>; /// Decides how text in a [`MultiBuffer`] should be displayed in a buffer, handling inlay hints,/// folding, hard tabs, soft wrapping, custom blocks (like diagnostics), and highlighting.////// See the [module level documentation](self) for more information.pub struct DisplayMap {    /// The buffer that we are displaying.    buffer: Model<MultiBuffer>,    buffer_subscription: BufferSubscription,    /// Decides where the [`Inlay`]s should be displayed.    inlay_map: InlayMap,    /// Decides where the fold indicators should be and tracks parts of a source file that are currently folded.    fold_map: FoldMap,    /// Keeps track of hard tabs in a buffer.    char_map: CharMap,    /// Handles soft wrapping.    wrap_map: Model<WrapMap>,    /// Tracks custom blocks such as diagnostics that should be displayed within buffer.    block_map: BlockMap,    /// Regions of text that should be highlighted.    text_highlights: TextHighlights,    /// Regions of inlays that should be highlighted.    inlay_highlights: InlayHighlights,    /// A container for explicitly foldable ranges, which supersede indentation based fold range suggestions.    crease_map: CreaseMap,    pub(crate) fold_placeholder: FoldPlaceholder,    pub clip_at_line_ends: bool,    pub(crate) masked: bool,} impl DisplayMap {    #[allow(clippy::too_many_arguments)]    pub fn new(        buffer: Model<MultiBuffer>,        font: Font,        font_size: Pixels,        wrap_width: Option<Pixels>,        show_excerpt_controls: bool,        buffer_header_height: u32,        excerpt_header_height: u32,        excerpt_footer_height: u32,        fold_placeholder: FoldPlaceholder,        cx: &mut ModelContext<Self>,    ) -> Self {        let buffer_subscription = buffer.update(cx, |buffer, _| buffer.subscribe());         let tab_size = Self::tab_size(&buffer, cx);        let buffer_snapshot = buffer.read(cx).snapshot(cx);        let crease_map = CreaseMap::new(&buffer_snapshot);        let (inlay_map, snapshot) = InlayMap::new(buffer_snapshot);        let (fold_map, snapshot) = FoldMap::new(snapshot);        let (char_map, snapshot) = CharMap::new(snapshot, tab_size);        let (wrap_map, snapshot) = WrapMap::new(snapshot, font, font_size, wrap_width, cx);        let block_map = BlockMap::new(            snapshot,            show_excerpt_controls,            buffer_header_height,            excerpt_header_height,            excerpt_footer_height,        );         cx.observe(&wrap_map, |_, _, cx| cx.notify()).detach();         DisplayMap {            buffer,            buffer_subscription,            fold_map,            inlay_map,            char_map,            wrap_map,            block_map,            crease_map,            fold_placeholder,            text_highlights: Default::default(),            inlay_highlights: Default::default(),            clip_at_line_ends: false,            masked: false,        }    }     pub fn snapshot(&mut self, cx: &mut ModelContext<Self>) -> DisplaySnapshot {        let buffer_snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let (inlay_snapshot, edits) = self.inlay_map.sync(buffer_snapshot, edits);        let (fold_snapshot, edits) = self.fold_map.read(inlay_snapshot.clone(), edits);        let tab_size = Self::tab_size(&self.buffer, cx);        let (char_snapshot, edits) = self.char_map.sync(fold_snapshot.clone(), edits, tab_size);        let (wrap_snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(char_snapshot.clone(), edits, cx));        let block_snapshot = self.block_map.read(wrap_snapshot.clone(), edits).snapshot;         DisplaySnapshot {            buffer_snapshot: self.buffer.read(cx).snapshot(cx),            fold_snapshot,            inlay_snapshot,            char_snapshot,            wrap_snapshot,            block_snapshot,            crease_snapshot: self.crease_map.snapshot(),            text_highlights: self.text_highlights.clone(),            inlay_highlights: self.inlay_highlights.clone(),            clip_at_line_ends: self.clip_at_line_ends,            masked: self.masked,            fold_placeholder: self.fold_placeholder.clone(),        }    }     pub fn set_state(&mut self, other: &DisplaySnapshot, cx: &mut ModelContext<Self>) {        self.fold(            other                .folds_in_range(0..other.buffer_snapshot.len())                .map(|fold| {                    (                        fold.range.to_offset(&other.buffer_snapshot),                        fold.placeholder.clone(),                    )                }),            cx,        );    }     pub fn fold<T: ToOffset>(        &mut self,        ranges: impl IntoIterator<Item = (Range<T>, FoldPlaceholder)>,        cx: &mut ModelContext<Self>,    ) {        let snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);        let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        self.block_map.read(snapshot, edits);        let (snapshot, edits) = fold_map.fold(ranges);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        self.block_map.read(snapshot, edits);    }     pub fn unfold<T: ToOffset>(        &mut self,        ranges: impl IntoIterator<Item = Range<T>>,        inclusive: bool,        cx: &mut ModelContext<Self>,    ) {        let snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);        let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        self.block_map.read(snapshot, edits);        let (snapshot, edits) = fold_map.unfold(ranges, inclusive);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        self.block_map.read(snapshot, edits);    }     pub fn insert_creases(        &mut self,        creases: impl IntoIterator<Item = Crease>,        cx: &mut ModelContext<Self>,    ) -> Vec<CreaseId> {        let snapshot = self.buffer.read(cx).snapshot(cx);        self.crease_map.insert(creases, &snapshot)    }     pub fn remove_creases(        &mut self,        crease_ids: impl IntoIterator<Item = CreaseId>,        cx: &mut ModelContext<Self>,    ) {        let snapshot = self.buffer.read(cx).snapshot(cx);        self.crease_map.remove(crease_ids, &snapshot)    }     pub fn insert_blocks(        &mut self,        blocks: impl IntoIterator<Item = BlockProperties<Anchor>>,        cx: &mut ModelContext<Self>,    ) -> Vec<CustomBlockId> {        let snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);        let (snapshot, edits) = self.fold_map.read(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        let mut block_map = self.block_map.write(snapshot, edits);        block_map.insert(blocks)    }     pub fn resize_blocks(        &mut self,        heights: HashMap<CustomBlockId, u32>,        cx: &mut ModelContext<Self>,    ) {        let snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);        let (snapshot, edits) = self.fold_map.read(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        let mut block_map = self.block_map.write(snapshot, edits);        block_map.resize(heights);    }     pub fn replace_blocks(&mut self, renderers: HashMap<CustomBlockId, RenderBlock>) {        self.block_map.replace_blocks(renderers);    }     pub fn remove_blocks(&mut self, ids: HashSet<CustomBlockId>, cx: &mut ModelContext<Self>) {        let snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);        let (snapshot, edits) = self.fold_map.read(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        let mut block_map = self.block_map.write(snapshot, edits);        block_map.remove(ids);    }     pub fn row_for_block(        &mut self,        block_id: CustomBlockId,        cx: &mut ModelContext<Self>,    ) -> Option<DisplayRow> {        let snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);        let (snapshot, edits) = self.fold_map.read(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        let block_map = self.block_map.read(snapshot, edits);        let block_row = block_map.row_for_block(block_id)?;        Some(DisplayRow(block_row.0))    }     pub fn highlight_text(        &mut self,        type_id: TypeId,        ranges: Vec<Range<Anchor>>,        style: HighlightStyle,    ) {        self.text_highlights            .insert(Some(type_id), Arc::new((style, ranges)));    }     pub(crate) fn highlight_inlays(        &mut self,        type_id: TypeId,        highlights: Vec<InlayHighlight>,        style: HighlightStyle,    ) {        for highlight in highlights {            let update = self.inlay_highlights.update(&type_id, |highlights| {                highlights.insert(highlight.inlay, (style, highlight.clone()))            });            if update.is_none() {                self.inlay_highlights.insert(                    type_id,                    TreeMap::from_ordered_entries([(highlight.inlay, (style, highlight))]),                );            }        }    }     pub fn text_highlights(&self, type_id: TypeId) -> Option<(HighlightStyle, &[Range<Anchor>])> {        let highlights = self.text_highlights.get(&Some(type_id))?;        Some((highlights.0, &highlights.1))    }    pub fn clear_highlights(&mut self, type_id: TypeId) -> bool {        let mut cleared = self.text_highlights.remove(&Some(type_id)).is_some();        cleared |= self.inlay_highlights.remove(&type_id).is_some();        cleared    }     pub fn set_font(&self, font: Font, font_size: Pixels, cx: &mut ModelContext<Self>) -> bool {        self.wrap_map            .update(cx, |map, cx| map.set_font_with_size(font, font_size, cx))    }     pub fn set_wrap_width(&self, width: Option<Pixels>, cx: &mut ModelContext<Self>) -> bool {        self.wrap_map            .update(cx, |map, cx| map.set_wrap_width(width, cx))    }     pub(crate) fn current_inlays(&self) -> impl Iterator<Item = &Inlay> {        self.inlay_map.current_inlays()    }     pub(crate) fn splice_inlays(        &mut self,        to_remove: Vec<InlayId>,        to_insert: Vec<Inlay>,        cx: &mut ModelContext<Self>,    ) {        if to_remove.is_empty() && to_insert.is_empty() {            return;        }        let buffer_snapshot = self.buffer.read(cx).snapshot(cx);        let edits = self.buffer_subscription.consume().into_inner();        let (snapshot, edits) = self.inlay_map.sync(buffer_snapshot, edits);        let (snapshot, edits) = self.fold_map.read(snapshot, edits);        let tab_size = Self::tab_size(&self.buffer, cx);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        self.block_map.read(snapshot, edits);         let (snapshot, edits) = self.inlay_map.splice(to_remove, to_insert);        let (snapshot, edits) = self.fold_map.read(snapshot, edits);        let (snapshot, edits) = self.char_map.sync(snapshot, edits, tab_size);        let (snapshot, edits) = self            .wrap_map            .update(cx, |map, cx| map.sync(snapshot, edits, cx));        self.block_map.read(snapshot, edits);    }     fn tab_size(buffer: &Model<MultiBuffer>, cx: &mut ModelContext<Self>) -> NonZeroU32 {        let buffer = buffer.read(cx).as_singleton().map(|buffer| buffer.read(cx));        let language = buffer            .and_then(|buffer| buffer.language())            .map(|l| l.name());        let file = buffer.and_then(|buffer| buffer.file());        language_settings(language, file, cx).tab_size    }     #[cfg(test)]    pub fn is_rewrapping(&self, cx: &gpui::AppContext) -> bool {        self.wrap_map.read(cx).is_rewrapping()    }     pub fn show_excerpt_controls(&self) -> bool {        self.block_map.show_excerpt_controls()    }} #[derive(Debug, Default)]pub(crate) struct Highlights<'a> {    pub text_highlights: Option<&'a TextHighlights>,    pub inlay_highlights: Option<&'a InlayHighlights>,    pub styles: HighlightStyles,} #[derive(Default, Debug, Clone, Copy)]pub struct HighlightStyles {    pub inlay_hint: Option<HighlightStyle>,    pub suggestion: Option<HighlightStyle>,} pub struct HighlightedChunk<'a> {    pub text: &'a str,    pub style: Option<HighlightStyle>,    pub is_tab: bool,    pub renderer: Option<ChunkRenderer>,} #[derive(Clone)]pub struct DisplaySnapshot {    pub buffer_snapshot: MultiBufferSnapshot,    pub fold_snapshot: FoldSnapshot,    pub crease_snapshot: CreaseSnapshot,    inlay_snapshot: InlaySnapshot,    char_snapshot: CharSnapshot,    wrap_snapshot: WrapSnapshot,    block_snapshot: BlockSnapshot,    text_highlights: TextHighlights,    inlay_highlights: InlayHighlights,    clip_at_line_ends: bool,    masked: bool,    pub(crate) fold_placeholder: FoldPlaceholder,} impl DisplaySnapshot {    #[cfg(test)]    pub fn fold_count(&self) -> usize {        self.fold_snapshot.fold_count()    }     pub fn is_empty(&self) -> bool {        self.buffer_snapshot.len() == 0    }     pub fn buffer_rows(        &self,        start_row: DisplayRow,    ) -> impl Iterator<Item = Option<MultiBufferRow>> + '_ {        self.block_snapshot            .buffer_rows(BlockRow(start_row.0))            .map(|row| row.map(|row| MultiBufferRow(row.0)))    }

Lines 1–500 of 2191. Load more