iced_code_editor/canvas_editor/features/folding/
ops.rs1use std::collections::HashSet;
6use std::rc::Rc;
7
8use crate::canvas_editor::CodeEditor;
9
10impl CodeEditor {
11 pub fn is_folded(&self, header_line: usize) -> bool {
13 self.collapsed_folds.contains(&header_line)
14 }
15
16 pub fn toggle_fold(&mut self, header_line: usize) {
27 let regions = self.foldable_regions();
28 if !super::is_fold_header(®ions, header_line) {
29 return; }
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 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 pub fn fold_at(&mut self, line: usize) {
78 let regions = self.foldable_regions();
79 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 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 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 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 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 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 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 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 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(®ions, &self.collapsed_folds)
200 }
201}
202
203#[cfg(test)]
204mod tests {
205 use super::*;
206
207 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 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); 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 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 editor.toggle_fold_at(3);
277 assert!(editor.is_folded(2));
278
279 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 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 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 editor.collapsed_folds.insert(0);
324 assert!(editor.hidden_lines_set().is_empty());
325 }
326}