Skip to main content

iced_code_editor/canvas_editor/features/folding/
ops.rs

1//! Fold/unfold operations on [`CodeEditor`](crate::canvas_editor::CodeEditor):
2//! toggling, folding, and unfolding regions, plus the cursor/cache upkeep
3//! that keeps folded state consistent with the buffer.
4
5use std::collections::HashSet;
6use std::rc::Rc;
7
8use crate::canvas_editor::CodeEditor;
9
10impl CodeEditor {
11    /// Returns whether the region whose header is `header_line` is collapsed.
12    pub fn is_folded(&self, header_line: usize) -> bool {
13        self.collapsed_folds.contains(&header_line)
14    }
15
16    /// Toggles the collapsed state of the foldable region whose header is
17    /// `header_line`.
18    ///
19    /// The call is a no-op if `header_line` is not currently a fold header.
20    /// When collapsing, any cursor that would land on a hidden line is moved up
21    /// to the header line so the caret stays visible.
22    ///
23    /// # Arguments
24    ///
25    /// * `header_line` - Logical line index of the region header
26    pub fn toggle_fold(&mut self, header_line: usize) {
27        let regions = self.foldable_regions();
28        if !super::is_fold_header(&regions, header_line) {
29            return; // Not a fold header: nothing to toggle.
30        }
31
32        if self.collapsed_folds.contains(&header_line) {
33            self.collapsed_folds.remove(&header_line);
34        } else {
35            self.collapsed_folds.insert(header_line);
36        }
37        self.after_fold_change();
38    }
39
40    /// Toggles the collapsed state of the innermost foldable region containing
41    /// `line`.
42    ///
43    /// Folds the region if it is expanded, unfolds it if it is collapsed. Does
44    /// nothing if `line` is not inside any foldable region. This is the
45    /// cursor-driven primitive used by the keyboard shortcut and mirrors a click
46    /// on the fold chevron.
47    ///
48    /// # Arguments
49    ///
50    /// * `line` - A logical line inside (or heading) the region to toggle
51    pub fn toggle_fold_at(&mut self, line: usize) {
52        let regions = self.foldable_regions();
53        let header = regions
54            .iter()
55            .filter(|r| r.start_line <= line && line <= r.end_line)
56            .map(|r| r.start_line)
57            .max();
58        if let Some(header) = header {
59            if self.collapsed_folds.contains(&header) {
60                self.collapsed_folds.remove(&header);
61            } else {
62                self.collapsed_folds.insert(header);
63            }
64            self.after_fold_change();
65        }
66    }
67
68    /// Folds the innermost foldable region containing `line`.
69    ///
70    /// Does nothing if `line` is not inside any foldable region or the region
71    /// is already collapsed. This is the cursor-driven counterpart to
72    /// [`Self::toggle_fold`].
73    ///
74    /// # Arguments
75    ///
76    /// * `line` - A logical line inside (or heading) the region to fold
77    pub fn fold_at(&mut self, line: usize) {
78        let regions = self.foldable_regions();
79        // Innermost containing region: the one with the greatest start line.
80        let header = regions
81            .iter()
82            .filter(|r| r.start_line <= line && line <= r.end_line)
83            .map(|r| r.start_line)
84            .max();
85        if let Some(header) = header
86            && self.collapsed_folds.insert(header)
87        {
88            self.after_fold_change();
89        }
90    }
91
92    /// Unfolds the innermost collapsed region containing `line`.
93    ///
94    /// Does nothing if no collapsed region contains `line`.
95    ///
96    /// # Arguments
97    ///
98    /// * `line` - A logical line inside (or heading) the region to unfold
99    pub fn unfold_at(&mut self, line: usize) {
100        let regions = self.foldable_regions();
101        let header = regions
102            .iter()
103            .filter(|r| {
104                r.start_line <= line
105                    && line <= r.end_line
106                    && self.collapsed_folds.contains(&r.start_line)
107            })
108            .map(|r| r.start_line)
109            .max();
110        if let Some(header) = header
111            && self.collapsed_folds.remove(&header)
112        {
113            self.after_fold_change();
114        }
115    }
116
117    /// Folds every foldable block in the buffer.
118    pub fn fold_all(&mut self) {
119        let regions = self.foldable_regions();
120        let mut changed = false;
121        for region in regions.iter() {
122            changed |= self.collapsed_folds.insert(region.start_line);
123        }
124        if changed {
125            self.after_fold_change();
126        }
127    }
128
129    /// Unfolds every collapsed block in the buffer.
130    pub fn unfold_all(&mut self) {
131        if !self.collapsed_folds.is_empty() {
132            self.collapsed_folds.clear();
133            self.after_fold_change();
134        }
135    }
136
137    /// Finalizes a change to the collapsed set: keeps every cursor on a visible
138    /// line and invalidates fold-dependent caches.
139    fn after_fold_change(&mut self) {
140        let hidden = self.hidden_lines_set();
141        self.move_cursors_out_of_hidden(&hidden);
142        self.bump_fold_revision();
143    }
144
145    /// Moves any cursor sitting on a hidden line up to the nearest visible line
146    /// above it (the header of the enclosing collapsed block).
147    fn move_cursors_out_of_hidden(&mut self, hidden: &HashSet<usize>) {
148        if hidden.is_empty() {
149            return;
150        }
151        for cursor in self.cursors.as_mut_slice() {
152            let mut line = cursor.position.0;
153            while line > 0 && hidden.contains(&line) {
154                line -= 1;
155            }
156            if line != cursor.position.0 {
157                cursor.position = (line, 0);
158            }
159        }
160        self.cursors.sort_and_merge();
161    }
162
163    /// Invalidates fold-dependent caches after a fold-state change.
164    pub(crate) fn bump_fold_revision(&mut self) {
165        self.fold_revision = self.fold_revision.wrapping_add(1);
166        self.content_cache.clear();
167        self.overlay_cache.clear();
168    }
169
170    /// Returns the foldable regions for the current buffer, memoized by
171    /// `buffer_revision`.
172    ///
173    /// Returns an empty list when folding is disabled.
174    pub(crate) fn foldable_regions(&self) -> Rc<Vec<super::FoldRegion>> {
175        if !self.folding_enabled {
176            return Rc::new(Vec::new());
177        }
178
179        let mut cache = self.foldable_regions_cache.borrow_mut();
180        if let Some((revision, regions)) = cache.as_ref()
181            && *revision == self.buffer_revision
182        {
183            return regions.clone();
184        }
185
186        let regions = Rc::new(super::compute_foldable_regions(&self.buffer));
187        *cache = Some((self.buffer_revision, regions.clone()));
188        regions
189    }
190
191    /// Returns the set of logical lines hidden by the currently collapsed folds.
192    ///
193    /// Empty when folding is disabled or nothing is collapsed.
194    pub(crate) fn hidden_lines_set(&self) -> HashSet<usize> {
195        if !self.folding_enabled || self.collapsed_folds.is_empty() {
196            return HashSet::new();
197        }
198        let regions = self.foldable_regions();
199        super::hidden_lines(&regions, &self.collapsed_folds)
200    }
201}
202
203#[cfg(test)]
204mod tests {
205    use super::*;
206
207    /// Buffer with one outer block (lines 0..=4) and a nested inner block
208    /// (lines 2..=3), used by the folding tests.
209    fn folding_editor() -> CodeEditor {
210        CodeEditor::new(
211            "fn main() {\n    let x = 1;\n    if x > 0 {\n        print();\n    }\n}",
212            "rs",
213        )
214    }
215
216    #[test]
217    fn test_foldable_regions_detected() {
218        let editor = folding_editor();
219        let regions = editor.foldable_regions();
220        assert_eq!(
221            *regions,
222            vec![
223                super::super::FoldRegion::new(0, 4),
224                super::super::FoldRegion::new(2, 3)
225            ]
226        );
227    }
228
229    #[test]
230    fn test_toggle_fold_hides_and_shows_lines() {
231        let mut editor = folding_editor();
232        let width = editor.viewport_width;
233        let total = editor.visual_lines_cached(width).len();
234
235        editor.toggle_fold(0);
236        assert!(editor.is_folded(0));
237        // Outer block hides lines 1..=4: only lines 0 and 5 remain.
238        assert_eq!(editor.visual_lines_cached(width).len(), 2);
239
240        editor.toggle_fold(0);
241        assert!(!editor.is_folded(0));
242        assert_eq!(editor.visual_lines_cached(width).len(), total);
243    }
244
245    #[test]
246    fn test_toggle_fold_ignores_non_header() {
247        let mut editor = folding_editor();
248        editor.toggle_fold(3); // line 3 is not a header
249        assert!(!editor.is_folded(3));
250        assert!(editor.collapsed_folds.is_empty());
251    }
252
253    #[test]
254    fn test_fold_at_picks_innermost_region() {
255        let mut editor = folding_editor();
256        // Line 3 is inside both (0,4) and (2,3); the innermost (header 2) folds.
257        editor.fold_at(3);
258        assert!(editor.is_folded(2));
259        assert!(!editor.is_folded(0));
260        assert_eq!(editor.hidden_lines_set(), [3].into_iter().collect());
261    }
262
263    #[test]
264    fn test_unfold_at_expands_innermost_region() {
265        let mut editor = folding_editor();
266        editor.fold_at(3);
267        editor.unfold_at(2);
268        assert!(!editor.is_folded(2));
269        assert!(editor.hidden_lines_set().is_empty());
270    }
271
272    #[test]
273    fn test_toggle_fold_at_cursor_folds_then_unfolds() {
274        let mut editor = folding_editor();
275        // Line 3 is inside the innermost region (header 2).
276        editor.toggle_fold_at(3);
277        assert!(editor.is_folded(2));
278
279        // Toggling again on the same line expands it back.
280        editor.toggle_fold_at(2);
281        assert!(!editor.is_folded(2));
282    }
283
284    #[test]
285    fn test_toggle_fold_at_ignores_unfoldable_line() {
286        let mut editor = CodeEditor::new("a\nb\nc", "rs");
287        editor.toggle_fold_at(1);
288        assert!(editor.collapsed_folds.is_empty());
289    }
290
291    #[test]
292    fn test_fold_all_and_unfold_all() {
293        let mut editor = folding_editor();
294        editor.fold_all();
295        assert!(editor.is_folded(0));
296        assert!(editor.is_folded(2));
297        // Outer fold hides 1..=4, inner hides 3: union is 1..=4.
298        assert_eq!(
299            editor.hidden_lines_set(),
300            [1, 2, 3, 4].into_iter().collect()
301        );
302
303        editor.unfold_all();
304        assert!(editor.collapsed_folds.is_empty());
305        assert!(editor.hidden_lines_set().is_empty());
306    }
307
308    #[test]
309    fn test_fold_moves_cursor_out_of_hidden_lines() {
310        let mut editor = folding_editor();
311        editor.cursors.set_single((3, 2));
312        editor.fold_all();
313        // Line 3 is hidden; the cursor moves up to the nearest visible line (0).
314        assert_eq!(editor.cursors.primary_position(), (0, 0));
315    }
316
317    #[test]
318    fn test_disabled_folding_yields_no_regions() {
319        let mut editor = folding_editor();
320        editor.set_folding_enabled(false);
321        assert!(editor.foldable_regions().is_empty());
322        // Collapsed state is preserved but produces no hidden lines while off.
323        editor.collapsed_folds.insert(0);
324        assert!(editor.hidden_lines_set().is_empty());
325    }
326}