Skip to main content

gpui_base/input/editor/
indent.rs

1use crate::input::InputModeKind;
2use crate::input::{
3    Indent, IndentInline, InputBaseState, Outdent, OutdentInline, RopeExt, element::TextElement,
4    layout::LastLayout, mode::LayoutMode,
5};
6use gpui::{
7    Bounds, Context, EntityInputHandler as _, Hsla, Path, PathBuilder, Pixels, SharedString,
8    TextRun, TextStyle, Window, point, px,
9};
10use ropey::RopeSlice;
11
12#[derive(Debug, Copy, Clone)]
13pub struct TabSize {
14    /// Default is 2
15    pub tab_size: usize,
16    /// Set true to use `\t` as tab indent, default is false
17    pub hard_tabs: bool,
18}
19
20impl Default for TabSize {
21    fn default() -> Self {
22        Self {
23            tab_size: 2,
24            hard_tabs: false,
25        }
26    }
27}
28
29impl TabSize {
30    pub(super) fn to_string(&self) -> SharedString {
31        if self.hard_tabs {
32            "\t".into()
33        } else {
34            " ".repeat(self.tab_size).into()
35        }
36    }
37
38    /// Count the indent size of the line in spaces.
39    pub fn indent_count(&self, line: &RopeSlice) -> usize {
40        let mut count = 0;
41        for ch in line.chars() {
42            match ch {
43                '\t' => count += self.tab_size,
44                ' ' => count += 1,
45                _ => break,
46            }
47        }
48        count
49    }
50}
51
52impl LayoutMode {
53    /// Whether this layout indents blocks.
54    ///
55    /// Callers gate this on the input being multi-line: indenting a one-line
56    /// text field has nothing to indent.
57    #[inline]
58    pub(super) fn is_indentable(&self) -> bool {
59        matches!(
60            self,
61            LayoutMode::PlainText { .. } | LayoutMode::CodeEditor { .. }
62        )
63    }
64
65    #[inline]
66    pub(super) fn has_indent_guides(&self) -> bool {
67        match self {
68            LayoutMode::CodeEditor { indent_guides, .. } => *indent_guides,
69            _ => false,
70        }
71    }
72
73    #[inline]
74    pub(super) fn tab_size(&self) -> TabSize {
75        match self {
76            LayoutMode::PlainText { tab, .. } => *tab,
77            LayoutMode::CodeEditor { tab, .. } => *tab,
78            _ => TabSize::default(),
79        }
80    }
81}
82
83impl<M: InputModeKind> TextElement<M> {
84    /// Measure the indent width in pixels for given column count.
85    fn measure_indent_width(&self, style: &TextStyle, column: usize, window: &Window) -> Pixels {
86        let font_size = style.font_size.to_pixels(window.rem_size());
87        let layout = window.text_system().shape_line(
88            SharedString::from(" ".repeat(column)),
89            font_size,
90            &[TextRun {
91                len: column,
92                font: style.font(),
93                color: Hsla::default(),
94                background_color: None,
95                strikethrough: None,
96                underline: None,
97                letter_spacing: None,
98            }],
99            None,
100        );
101
102        layout.width
103    }
104
105    pub(super) fn layout_indent_guides(
106        &self,
107        state: &InputBaseState<M>,
108        bounds: &Bounds<Pixels>,
109        last_layout: &LastLayout,
110        text_style: &TextStyle,
111        window: &mut Window,
112    ) -> Option<Path<Pixels>> {
113        if !state.is_multi_line() || !state.mode.has_indent_guides() {
114            return None;
115        }
116
117        let indent_width =
118            self.measure_indent_width(text_style, state.mode.tab_size().tab_size, window);
119
120        let tab_size = state.mode.tab_size();
121        let line_height = last_layout.line_height;
122        let mut builder = PathBuilder::stroke(px(1.));
123        let mut offset_y = last_layout.visible_top;
124        let mut last_indents = vec![];
125
126        for (&buffer_line, line_layout) in last_layout
127            .visible_buffer_lines
128            .iter()
129            .zip(last_layout.lines.iter())
130        {
131            let line = state.text.slice_line(buffer_line);
132            let mut current_indents = vec![];
133            if line.len() > 0 {
134                let indent_count = tab_size.indent_count(&line);
135                for offset in (0..indent_count).step_by(tab_size.tab_size) {
136                    let x = if indent_count > 0 {
137                        indent_width * offset as f32 / tab_size.tab_size as f32
138                    } else {
139                        px(0.)
140                    };
141
142                    let pos = point(x + last_layout.line_number_width, offset_y);
143
144                    builder.move_to(pos);
145                    builder.line_to(point(pos.x, pos.y + line_height));
146                    current_indents.push(pos.x);
147                }
148            } else if last_indents.len() > 0 {
149                for x in &last_indents {
150                    let pos = point(*x, offset_y);
151                    builder.move_to(pos);
152                    builder.line_to(point(pos.x, pos.y + line_height));
153                }
154                current_indents = last_indents.clone();
155            }
156
157            offset_y += line_layout.wrapped_lines.len() * line_height;
158            last_indents = current_indents;
159        }
160
161        builder.translate(bounds.origin);
162        let path = builder.build().unwrap();
163        Some(path)
164    }
165}
166
167/// Indent guides are a code-editor affordance.
168impl InputBaseState<crate::input::EditorMode> {
169    /// Set whether to show indent guides, default is true.
170    #[doc(hidden)]
171    pub fn indent_guides(mut self, indent_guides: bool) -> Self {
172        if let LayoutMode::CodeEditor {
173            indent_guides: l, ..
174        } = &mut self.mode
175        {
176            *l = indent_guides;
177        }
178        self
179    }
180
181    /// Set indent guides at runtime.
182    pub fn set_indent_guides(
183        &mut self,
184        indent_guides: bool,
185        _: &mut Window,
186        cx: &mut Context<Self>,
187    ) {
188        if let LayoutMode::CodeEditor {
189            indent_guides: l, ..
190        } = &mut self.mode
191        {
192            *l = indent_guides;
193        }
194        cx.notify();
195    }
196}
197
198impl<M: InputModeKind> InputBaseState<M> {
199    pub(super) fn indent_inline(
200        &mut self,
201        _: &IndentInline,
202        window: &mut Window,
203        cx: &mut Context<Self>,
204    ) {
205        // First, try to accept inline completion if present
206        if M::accept_inline_completion(self, window, cx) {
207            return;
208        }
209        self.indent(false, window, cx);
210    }
211
212    pub(super) fn indent_block(&mut self, _: &Indent, window: &mut Window, cx: &mut Context<Self>) {
213        self.indent(true, window, cx);
214    }
215
216    pub(super) fn outdent_inline(
217        &mut self,
218        _: &OutdentInline,
219        window: &mut Window,
220        cx: &mut Context<Self>,
221    ) {
222        self.outdent(false, window, cx);
223    }
224
225    pub(super) fn outdent_block(
226        &mut self,
227        _: &Outdent,
228        window: &mut Window,
229        cx: &mut Context<Self>,
230    ) {
231        self.outdent(true, window, cx);
232    }
233
234    pub(super) fn indent(&mut self, block: bool, window: &mut Window, cx: &mut Context<Self>) {
235        if !self.is_multi_line() || !self.mode.is_indentable() {
236            cx.propagate();
237            return;
238        };
239
240        let tab_indent = self.mode.tab_size().to_string();
241        let selected_range = self.selected_range;
242        let mut added_len = 0;
243        let is_selected = !self.selected_range.is_empty();
244
245        if is_selected || block {
246            let start_offset = self.start_of_line_of_selection(window, cx);
247            let mut offset = start_offset;
248
249            let selected_text = self
250                .text_for_range(
251                    self.range_to_utf16(&(offset..selected_range.end)),
252                    &mut None,
253                    window,
254                    cx,
255                )
256                .unwrap_or("".into());
257
258            for line in selected_text.split('\n') {
259                self.replace_text_in_range_silent(
260                    Some(self.range_to_utf16(&(offset..offset))),
261                    &tab_indent,
262                    window,
263                    cx,
264                );
265                added_len += tab_indent.len();
266                // +1 for "\n", the `\r` is included in the `line`.
267                offset += line.len() + tab_indent.len() + 1;
268            }
269
270            if is_selected {
271                self.selected_range = (start_offset..selected_range.end + added_len).into();
272            } else {
273                self.selected_range =
274                    (selected_range.start + added_len..selected_range.end + added_len).into();
275            }
276        } else {
277            // Selected none
278            let offset = self.selected_range.start;
279            self.replace_text_in_range_silent(
280                Some(self.range_to_utf16(&(offset..offset))),
281                &tab_indent,
282                window,
283                cx,
284            );
285            added_len = tab_indent.len();
286
287            self.selected_range =
288                (selected_range.start + added_len..selected_range.end + added_len).into();
289        }
290    }
291
292    pub(super) fn outdent(&mut self, block: bool, window: &mut Window, cx: &mut Context<Self>) {
293        if !self.is_multi_line() || !self.mode.is_indentable() {
294            cx.propagate();
295            return;
296        };
297
298        let tab_indent = self.mode.tab_size().to_string();
299        let selected_range = self.selected_range;
300        let mut removed_len = 0;
301        let is_selected = !self.selected_range.is_empty();
302
303        if is_selected || block {
304            let start_offset = self.start_of_line_of_selection(window, cx);
305            let mut offset = start_offset;
306
307            let selected_text = self
308                .text_for_range(
309                    self.range_to_utf16(&(offset..selected_range.end)),
310                    &mut None,
311                    window,
312                    cx,
313                )
314                .unwrap_or("".into());
315
316            for line in selected_text.split('\n') {
317                if line.starts_with(tab_indent.as_ref()) {
318                    self.replace_text_in_range_silent(
319                        Some(self.range_to_utf16(&(offset..offset + tab_indent.len()))),
320                        "",
321                        window,
322                        cx,
323                    );
324                    removed_len += tab_indent.len();
325
326                    // +1 for "\n"
327                    offset += line.len().saturating_sub(tab_indent.len()) + 1;
328                } else {
329                    offset += line.len() + 1;
330                }
331            }
332
333            if is_selected {
334                self.selected_range =
335                    (start_offset..selected_range.end.saturating_sub(removed_len)).into();
336            } else {
337                self.selected_range = (selected_range.start.saturating_sub(removed_len)
338                    ..selected_range.end.saturating_sub(removed_len))
339                    .into();
340            }
341        } else {
342            // Selected none
343            let start_offset = self.selected_range.start;
344            let offset = self.start_of_line_of_selection(window, cx);
345            let offset = self.offset_from_utf16(self.offset_to_utf16(offset));
346
347            if self
348                .text
349                .slice(offset..self.text.len())
350                .chars()
351                .take(tab_indent.chars().count())
352                .eq(tab_indent.chars())
353            {
354                self.replace_text_in_range_silent(
355                    Some(self.range_to_utf16(&(offset..offset + tab_indent.len()))),
356                    "",
357                    window,
358                    cx,
359                );
360                removed_len = tab_indent.len();
361                let new_offset = start_offset.saturating_sub(removed_len);
362                self.selected_range = (new_offset..new_offset).into();
363            }
364        }
365    }
366}
367
368#[cfg(test)]
369mod tests {
370    use ropey::RopeSlice;
371
372    use super::TabSize;
373
374    #[test]
375    fn test_tab_size() {
376        let tab = TabSize {
377            tab_size: 2,
378            hard_tabs: false,
379        };
380        assert_eq!(tab.to_string(), "  ");
381        let tab = TabSize {
382            tab_size: 4,
383            hard_tabs: false,
384        };
385        assert_eq!(tab.to_string(), "    ");
386
387        let tab = TabSize {
388            tab_size: 2,
389            hard_tabs: true,
390        };
391        assert_eq!(tab.to_string(), "\t");
392        let tab = TabSize {
393            tab_size: 4,
394            hard_tabs: true,
395        };
396        assert_eq!(tab.to_string(), "\t");
397    }
398
399    #[test]
400    fn test_tab_size_indent_count() {
401        let tab = TabSize {
402            tab_size: 4,
403            hard_tabs: false,
404        };
405        assert_eq!(tab.indent_count(&RopeSlice::from("abc")), 0);
406        assert_eq!(tab.indent_count(&RopeSlice::from("  abc")), 2);
407        assert_eq!(tab.indent_count(&RopeSlice::from("    abc")), 4);
408        assert_eq!(tab.indent_count(&RopeSlice::from("\tabc")), 4);
409        assert_eq!(tab.indent_count(&RopeSlice::from("  \tabc")), 6);
410        assert_eq!(tab.indent_count(&RopeSlice::from(" \t abc  ")), 6);
411        assert_eq!(tab.indent_count(&RopeSlice::from("abc")), 0);
412    }
413}
414
415/// Tab size only means something where there is more than one line to indent.
416impl<M: crate::input::MultiLineMode> InputBaseState<M> {
417    /// Set the tab size for the input.
418    #[doc(hidden)]
419    pub fn tab_size(mut self, tab: TabSize) -> Self {
420        match &mut self.mode {
421            LayoutMode::PlainText { tab: t, .. } => *t = tab,
422            LayoutMode::CodeEditor { tab: t, .. } => *t = tab,
423            _ => {}
424        }
425        self
426    }
427
428    pub fn set_tab_size(&mut self, tab: TabSize, cx: &mut Context<Self>) {
429        match &mut self.mode {
430            LayoutMode::PlainText { tab: value, .. }
431            | LayoutMode::CodeEditor { tab: value, .. } => *value = tab,
432            _ => {}
433        }
434        cx.notify();
435    }
436}