use super::*; impl GutterDimensions {    /// The width of the space reserved for the fold indicators,    /// use alongside 'justify_end' and `gutter_width` to    /// right align content with the line numbers    pub fn fold_area_width(&self) -> Pixels {        self.margin + self.right_padding    }} impl EditorSnapshot {    pub fn render_crease_toggle(        &self,        buffer_row: MultiBufferRow,        row_contains_cursor: bool,        editor: Entity<Editor>,        window: &mut Window,        cx: &mut App,    ) -> Option<AnyElement> {        let folded = self.is_line_folded(buffer_row);        let mut is_foldable = false;         if let Some(crease) = self            .crease_snapshot            .query_row(buffer_row, self.buffer_snapshot())        {            is_foldable = true;            match crease {                Crease::Inline { render_toggle, .. } | Crease::Block { render_toggle, .. } => {                    if let Some(render_toggle) = render_toggle {                        let toggle_callback =                            Arc::new(move |folded, window: &mut Window, cx: &mut App| {                                if folded {                                    editor.update(cx, |editor, cx| {                                        editor.fold_at(buffer_row, window, cx)                                    });                                } else {                                    editor.update(cx, |editor, cx| {                                        editor.unfold_at(buffer_row, window, cx)                                    });                                }                            });                        return Some((render_toggle)(                            buffer_row,                            folded,                            toggle_callback,                            window,                            cx,                        ));                    }                }            }        }         is_foldable |= !self.use_lsp_folding_ranges && self.starts_indent(buffer_row);         if folded || (is_foldable && (row_contains_cursor || self.gutter_hovered)) {            Some(                Disclosure::new(("gutter_crease", buffer_row.0), !folded)                    .toggle_state(folded)                    .on_click(window.listener_for(&editor, move |this, _e, window, cx| {                        if folded {                            this.unfold_at(buffer_row, window, cx);                        } else {                            this.fold_at(buffer_row, window, cx);                        }                    }))                    .into_any_element(),            )        } else {            None        }    }     pub fn render_crease_trailer(        &self,        buffer_row: MultiBufferRow,        window: &mut Window,        cx: &mut App,    ) -> Option<AnyElement> {        let folded = self.is_line_folded(buffer_row);        if let Crease::Inline { render_trailer, .. } = self            .crease_snapshot            .query_row(buffer_row, self.buffer_snapshot())?        {            let render_trailer = render_trailer.as_ref()?;            Some(render_trailer(buffer_row, folded, window, cx))        } else {            None        }    }} impl Editor {    pub fn toggle_fold(        &mut self,        _: &actions::ToggleFold,        window: &mut Window,        cx: &mut Context<Self>,    ) {        if self.buffer_kind(cx) == ItemBufferKind::Singleton {            let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));            let selection = self.selections.newest::<Point>(&display_map);             let range = if selection.is_empty() {                let point = selection.head().to_display_point(&display_map);                let start = DisplayPoint::new(point.row(), 0).to_point(&display_map);                let end = DisplayPoint::new(point.row(), display_map.line_len(point.row()))                    .to_point(&display_map);                start..end            } else {                selection.range()            };            if display_map.folds_in_range(range).next().is_some() {                self.unfold_lines(&Default::default(), window, cx)            } else {                self.fold(&Default::default(), window, cx)            }        } else {            let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);            let buffer_ids: HashSet<_> = self                .selections                .disjoint_anchor_ranges()                .flat_map(|range| multi_buffer_snapshot.buffer_ids_for_range(range))                .collect();             let should_unfold = buffer_ids                .iter()                .any(|buffer_id| self.is_buffer_folded(*buffer_id, cx));             for buffer_id in buffer_ids {                if should_unfold {                    self.unfold_buffer(buffer_id, cx);                } else {                    self.fold_buffer(buffer_id, cx);                }            }        }    }     pub fn toggle_fold_recursive(        &mut self,        _: &actions::ToggleFoldRecursive,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let selection = self.selections.newest::<Point>(&self.display_snapshot(cx));         let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));        let range = if selection.is_empty() {            let point = selection.head().to_display_point(&display_map);            let start = DisplayPoint::new(point.row(), 0).to_point(&display_map);            let end = DisplayPoint::new(point.row(), display_map.line_len(point.row()))                .to_point(&display_map);            start..end        } else {            selection.range()        };        if display_map.folds_in_range(range).next().is_some() {            self.unfold_recursive(&Default::default(), window, cx)        } else {            self.fold_recursive(&Default::default(), window, cx)        }    }     pub fn fold(&mut self, _: &actions::Fold, window: &mut Window, cx: &mut Context<Self>) {        if self.buffer_kind(cx) == ItemBufferKind::Singleton {            let mut to_fold = Vec::new();            let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));            let selections = self.selections.all_adjusted(&display_map);             for selection in selections {                let range = selection.range().sorted();                let buffer_start_row = range.start.row;                 if range.start.row != range.end.row {                    let mut found = false;                    let mut row = range.start.row;                    while row <= range.end.row {                        if let Some(crease) = display_map.crease_for_buffer_row(MultiBufferRow(row))                        {                            found = true;                            row = crease.range().end.row + 1;                            to_fold.push(crease);                        } else {                            row += 1                        }                    }                    if found {                        continue;                    }                }                 for row in (0..=range.start.row).rev() {                    if let Some(crease) = display_map.crease_for_buffer_row(MultiBufferRow(row))                        && crease.range().end.row >= buffer_start_row                    {                        to_fold.push(crease);                        if row <= range.start.row {                            break;                        }                    }                }            }             self.fold_creases(to_fold, true, window, cx);        } else {            let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);            let buffer_ids = self                .selections                .disjoint_anchor_ranges()                .flat_map(|range| multi_buffer_snapshot.buffer_ids_for_range(range))                .collect::<HashSet<_>>();            for buffer_id in buffer_ids {                self.fold_buffer(buffer_id, cx);            }        }    }     pub fn toggle_fold_all(        &mut self,        _: &actions::ToggleFoldAll,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let has_folds = if self.buffer.read(cx).is_singleton() {            let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));            let has_folds = display_map                .folds_in_range(MultiBufferOffset(0)..display_map.buffer_snapshot().len())                .next()                .is_some();            has_folds        } else {            let snapshot = self.buffer.read(cx).snapshot(cx);            let has_folds = snapshot                .all_buffer_ids()                .any(|buffer_id| self.is_buffer_folded(buffer_id, cx));            has_folds        };         if has_folds {            self.unfold_all(&actions::UnfoldAll, window, cx);        } else {            self.fold_all(&actions::FoldAll, window, cx);        }    }     pub fn fold_at_level_1(        &mut self,        _: &actions::FoldAtLevel1,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(1), window, cx);    }     pub fn fold_at_level_2(        &mut self,        _: &actions::FoldAtLevel2,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(2), window, cx);    }     pub fn fold_at_level_3(        &mut self,        _: &actions::FoldAtLevel3,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(3), window, cx);    }     pub fn fold_at_level_4(        &mut self,        _: &actions::FoldAtLevel4,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(4), window, cx);    }     pub fn fold_at_level_5(        &mut self,        _: &actions::FoldAtLevel5,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(5), window, cx);    }     pub fn fold_at_level_6(        &mut self,        _: &actions::FoldAtLevel6,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(6), window, cx);    }     pub fn fold_at_level_7(        &mut self,        _: &actions::FoldAtLevel7,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(7), window, cx);    }     pub fn fold_at_level_8(        &mut self,        _: &actions::FoldAtLevel8,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(8), window, cx);    }     pub fn fold_at_level_9(        &mut self,        _: &actions::FoldAtLevel9,        window: &mut Window,        cx: &mut Context<Self>,    ) {        self.fold_at_level(&actions::FoldAtLevel(9), window, cx);    }     pub fn fold_all(&mut self, _: &actions::FoldAll, window: &mut Window, cx: &mut Context<Self>) {        if self.buffer.read(cx).is_singleton() {            let mut fold_ranges = Vec::new();            let snapshot = self.buffer.read(cx).snapshot(cx);             for row in 0..snapshot.max_row().0 {                if let Some(foldable_range) = self                    .snapshot(window, cx)                    .crease_for_buffer_row(MultiBufferRow(row))                {                    fold_ranges.push(foldable_range);                }            }             self.fold_creases(fold_ranges, true, window, cx);        } else {            self.toggle_fold_multiple_buffers = cx.spawn_in(window, async move |editor, cx| {                editor                    .update_in(cx, |editor, _, cx| {                        let snapshot = editor.buffer.read(cx).snapshot(cx);                        for buffer_id in snapshot.all_buffer_ids() {                            editor.fold_buffer(buffer_id, cx);                        }                    })                    .ok();            });        }    }     pub fn fold_function_bodies(        &mut self,        _: &actions::FoldFunctionBodies,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let snapshot = self.buffer.read(cx).snapshot(cx);         let ranges = snapshot            .text_object_ranges(                MultiBufferOffset(0)..snapshot.len(),                TreeSitterOptions::default(),            )            .filter_map(|(range, obj)| (obj == TextObject::InsideFunction).then_some(range))            .collect::<Vec<_>>();         let creases = ranges            .into_iter()            .map(|range| Crease::simple(range, self.display_map.read(cx).fold_placeholder.clone()))            .collect();         self.fold_creases(creases, true, window, cx);    }     pub fn fold_recursive(        &mut self,        _: &actions::FoldRecursive,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let mut to_fold = Vec::new();        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));        let selections = self.selections.all_adjusted(&display_map);         for selection in selections {            let range = selection.range().sorted();            let buffer_start_row = range.start.row;             if range.start.row != range.end.row {                let mut found = false;                for row in range.start.row..=range.end.row {                    if let Some(crease) = display_map.crease_for_buffer_row(MultiBufferRow(row)) {                        found = true;                        to_fold.push(crease);                    }                }                if found {                    continue;                }            }             for row in (0..=range.start.row).rev() {                if let Some(crease) = display_map.crease_for_buffer_row(MultiBufferRow(row)) {                    if crease.range().end.row >= buffer_start_row {                        to_fold.push(crease);                    } else {                        break;                    }                }            }        }         self.fold_creases(to_fold, true, window, cx);    }     pub fn fold_at(        &mut self,        buffer_row: MultiBufferRow,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));         if let Some(crease) = display_map.crease_for_buffer_row(buffer_row) {            let autoscroll = self                .selections                .all::<Point>(&display_map)                .iter()                .any(|selection| crease.range().overlaps(&selection.range()));             self.fold_creases(vec![crease], autoscroll, window, cx);        }    }     pub fn unfold_lines(&mut self, _: &UnfoldLines, _window: &mut Window, cx: &mut Context<Self>) {        if self.buffer_kind(cx) == ItemBufferKind::Singleton {            let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));            let buffer = display_map.buffer_snapshot();            let selections = self.selections.all::<Point>(&display_map);            let ranges = selections                .iter()                .map(|s| {                    let range = s.display_range(&display_map).sorted();                    let mut start = range.start.to_point(&display_map);                    let mut end = range.end.to_point(&display_map);                    start.column = 0;                    end.column = buffer.line_len(MultiBufferRow(end.row));                    start..end                })                .collect::<Vec<_>>();             self.unfold_ranges(&ranges, true, true, cx);        } else {            let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);            let buffer_ids = self                .selections                .disjoint_anchor_ranges()                .flat_map(|range| multi_buffer_snapshot.buffer_ids_for_range(range))                .collect::<HashSet<_>>();            for buffer_id in buffer_ids {                self.unfold_buffer(buffer_id, cx);            }        }    }     pub fn unfold_recursive(        &mut self,        _: &UnfoldRecursive,        _window: &mut Window,        cx: &mut Context<Self>,    ) {        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));        let selections = self.selections.all::<Point>(&display_map);        let ranges = selections            .iter()            .map(|s| {                let mut range = s.display_range(&display_map).sorted();                *range.start.column_mut() = 0;                *range.end.column_mut() = display_map.line_len(range.end.row());                let start = range.start.to_point(&display_map);                let end = range.end.to_point(&display_map);                start..end            })            .collect::<Vec<_>>();         self.unfold_ranges(&ranges, true, true, cx);    }     pub fn unfold_at(        &mut self,        buffer_row: MultiBufferRow,        _window: &mut Window,

Lines 1–500 of 1095. Load more