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 pub tab_size: usize,
16 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 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 #[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 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
167impl InputBaseState<crate::input::EditorMode> {
169 #[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 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 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 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 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 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 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
415impl<M: crate::input::MultiLineMode> InputBaseState<M> {
417 #[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}