1mod block_map;
2mod fold_map;
3mod inlay_map;
4mod tab_map;
5mod wrap_map;
6
7use crate::EditorStyle;
8use crate::{
9 link_go_to_definition::InlayHighlight, movement::TextLayoutDetails, Anchor, AnchorRangeExt,
10 InlayId, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint,
11};
12pub use block_map::{BlockMap, BlockPoint};
13use collections::{BTreeMap, HashMap, HashSet};
14use fold_map::FoldMap;
15use gpui::{
16 Font, FontId, HighlightStyle, Hsla, LineLayout, Model, ModelContext, Pixels, ShapedLine,
17 TextRun, UnderlineStyle, WrappedLine,
18};
19use inlay_map::InlayMap;
20use language::{
21 language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription,
22};
23use lsp::DiagnosticSeverity;
24use std::{any::TypeId, borrow::Cow, fmt::Debug, num::NonZeroU32, ops::Range, sync::Arc};
25use sum_tree::{Bias, TreeMap};
26use tab_map::TabMap;
27use theme::{StatusColors, SyntaxTheme, Theme};
28use wrap_map::WrapMap;
29
30pub use block_map::{
31 BlockBufferRows as DisplayBufferRows, BlockChunks as DisplayChunks, BlockContext,
32 BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock,
33};
34
35pub use self::fold_map::{Fold, FoldPoint};
36pub use self::inlay_map::{Inlay, InlayOffset, InlayPoint};
37
38#[derive(Copy, Clone, Debug, PartialEq, Eq)]
39pub enum FoldStatus {
40 Folded,
41 Foldable,
42}
43
44const UNNECESSARY_CODE_FADE: f32 = 0.3;
45
46pub trait ToDisplayPoint {
47 fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint;
48}
49
50type TextHighlights = TreeMap<Option<TypeId>, Arc<(HighlightStyle, Vec<Range<Anchor>>)>>;
51type InlayHighlights = BTreeMap<TypeId, HashMap<InlayId, (HighlightStyle, InlayHighlight)>>;
52
53pub struct DisplayMap {
54 buffer: Model<MultiBuffer>,
55 buffer_subscription: BufferSubscription,
56 fold_map: FoldMap,
57 inlay_map: InlayMap,
58 tab_map: TabMap,
59 wrap_map: Model<WrapMap>,
60 block_map: BlockMap,
61 text_highlights: TextHighlights,
62 inlay_highlights: InlayHighlights,
63 pub clip_at_line_ends: bool,
64}
65
66impl DisplayMap {
67 pub fn new(
68 buffer: Model<MultiBuffer>,
69 font: Font,
70 font_size: Pixels,
71 wrap_width: Option<Pixels>,
72 buffer_header_height: u8,
73 excerpt_header_height: u8,
74 cx: &mut ModelContext<Self>,
75 ) -> Self {
76 let buffer_subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
77
78 let tab_size = Self::tab_size(&buffer, cx);
79 let (inlay_map, snapshot) = InlayMap::new(buffer.read(cx).snapshot(cx));
80 let (fold_map, snapshot) = FoldMap::new(snapshot);
81 let (tab_map, snapshot) = TabMap::new(snapshot, tab_size);
82 let (wrap_map, snapshot) = WrapMap::new(snapshot, font, font_size, wrap_width, cx);
83 let block_map = BlockMap::new(snapshot, buffer_header_height, excerpt_header_height);
84 cx.observe(&wrap_map, |_, _, cx| cx.notify()).detach();
85 DisplayMap {
86 buffer,
87 buffer_subscription,
88 fold_map,
89 inlay_map,
90 tab_map,
91 wrap_map,
92 block_map,
93 text_highlights: Default::default(),
94 inlay_highlights: Default::default(),
95 clip_at_line_ends: false,
96 }
97 }
98
99 pub fn snapshot(&mut self, cx: &mut ModelContext<Self>) -> DisplaySnapshot {
100 let buffer_snapshot = self.buffer.read(cx).snapshot(cx);
101 let edits = self.buffer_subscription.consume().into_inner();
102 let (inlay_snapshot, edits) = self.inlay_map.sync(buffer_snapshot, edits);
103 let (fold_snapshot, edits) = self.fold_map.read(inlay_snapshot.clone(), edits);
104 let tab_size = Self::tab_size(&self.buffer, cx);
105 let (tab_snapshot, edits) = self.tab_map.sync(fold_snapshot.clone(), edits, tab_size);
106 let (wrap_snapshot, edits) = self
107 .wrap_map
108 .update(cx, |map, cx| map.sync(tab_snapshot.clone(), edits, cx));
109 let block_snapshot = self.block_map.read(wrap_snapshot.clone(), edits);
110
111 DisplaySnapshot {
112 buffer_snapshot: self.buffer.read(cx).snapshot(cx),
113 fold_snapshot,
114 inlay_snapshot,
115 tab_snapshot,
116 wrap_snapshot,
117 block_snapshot,
118 text_highlights: self.text_highlights.clone(),
119 inlay_highlights: self.inlay_highlights.clone(),
120 clip_at_line_ends: self.clip_at_line_ends,
121 }
122 }
123
124 pub fn set_state(&mut self, other: &DisplaySnapshot, cx: &mut ModelContext<Self>) {
125 self.fold(
126 other
127 .folds_in_range(0..other.buffer_snapshot.len())
128 .map(|fold| fold.range.to_offset(&other.buffer_snapshot)),
129 cx,
130 );
131 }
132
133 pub fn fold<T: ToOffset>(
134 &mut self,
135 ranges: impl IntoIterator<Item = Range<T>>,
136 cx: &mut ModelContext<Self>,
137 ) {
138 let snapshot = self.buffer.read(cx).snapshot(cx);
139 let edits = self.buffer_subscription.consume().into_inner();
140 let tab_size = Self::tab_size(&self.buffer, cx);
141 let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
142 let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
143 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
144 let (snapshot, edits) = self
145 .wrap_map
146 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
147 self.block_map.read(snapshot, edits);
148 let (snapshot, edits) = fold_map.fold(ranges);
149 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
150 let (snapshot, edits) = self
151 .wrap_map
152 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
153 self.block_map.read(snapshot, edits);
154 }
155
156 pub fn unfold<T: ToOffset>(
157 &mut self,
158 ranges: impl IntoIterator<Item = Range<T>>,
159 inclusive: bool,
160 cx: &mut ModelContext<Self>,
161 ) {
162 let snapshot = self.buffer.read(cx).snapshot(cx);
163 let edits = self.buffer_subscription.consume().into_inner();
164 let tab_size = Self::tab_size(&self.buffer, cx);
165 let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
166 let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
167 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
168 let (snapshot, edits) = self
169 .wrap_map
170 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
171 self.block_map.read(snapshot, edits);
172 let (snapshot, edits) = fold_map.unfold(ranges, inclusive);
173 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
174 let (snapshot, edits) = self
175 .wrap_map
176 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
177 self.block_map.read(snapshot, edits);
178 }
179
180 pub fn insert_blocks(
181 &mut self,
182 blocks: impl IntoIterator<Item = BlockProperties<Anchor>>,
183 cx: &mut ModelContext<Self>,
184 ) -> Vec<BlockId> {
185 let snapshot = self.buffer.read(cx).snapshot(cx);
186 let edits = self.buffer_subscription.consume().into_inner();
187 let tab_size = Self::tab_size(&self.buffer, cx);
188 let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
189 let (snapshot, edits) = self.fold_map.read(snapshot, edits);
190 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
191 let (snapshot, edits) = self
192 .wrap_map
193 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
194 let mut block_map = self.block_map.write(snapshot, edits);
195 block_map.insert(blocks)
196 }
197
198 pub fn replace_blocks(&mut self, styles: HashMap<BlockId, RenderBlock>) {
199 self.block_map.replace(styles);
200 }
201
202 pub fn remove_blocks(&mut self, ids: HashSet<BlockId>, cx: &mut ModelContext<Self>) {
203 let snapshot = self.buffer.read(cx).snapshot(cx);
204 let edits = self.buffer_subscription.consume().into_inner();
205 let tab_size = Self::tab_size(&self.buffer, cx);
206 let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
207 let (snapshot, edits) = self.fold_map.read(snapshot, edits);
208 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
209 let (snapshot, edits) = self
210 .wrap_map
211 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
212 let mut block_map = self.block_map.write(snapshot, edits);
213 block_map.remove(ids);
214 }
215
216 pub fn highlight_text(
217 &mut self,
218 type_id: TypeId,
219 ranges: Vec<Range<Anchor>>,
220 style: HighlightStyle,
221 ) {
222 self.text_highlights
223 .insert(Some(type_id), Arc::new((style, ranges)));
224 }
225
226 pub fn highlight_inlays(
227 &mut self,
228 type_id: TypeId,
229 highlights: Vec<InlayHighlight>,
230 style: HighlightStyle,
231 ) {
232 for highlight in highlights {
233 self.inlay_highlights
234 .entry(type_id)
235 .or_default()
236 .insert(highlight.inlay, (style, highlight));
237 }
238 }
239
240 pub fn text_highlights(&self, type_id: TypeId) -> Option<(HighlightStyle, &[Range<Anchor>])> {
241 let highlights = self.text_highlights.get(&Some(type_id))?;
242 Some((highlights.0, &highlights.1))
243 }
244 pub fn clear_highlights(&mut self, type_id: TypeId) -> bool {
245 let mut cleared = self.text_highlights.remove(&Some(type_id)).is_some();
246 cleared |= self.inlay_highlights.remove(&type_id).is_none();
247 cleared
248 }
249
250 pub fn set_font(&self, font: Font, font_size: Pixels, cx: &mut ModelContext<Self>) -> bool {
251 self.wrap_map
252 .update(cx, |map, cx| map.set_font_with_size(font, font_size, cx))
253 }
254
255 pub fn set_fold_ellipses_color(&mut self, color: Hsla) -> bool {
256 self.fold_map.set_ellipses_color(color)
257 }
258
259 pub fn set_wrap_width(&self, width: Option<Pixels>, cx: &mut ModelContext<Self>) -> bool {
260 self.wrap_map
261 .update(cx, |map, cx| map.set_wrap_width(width, cx))
262 }
263
264 pub fn current_inlays(&self) -> impl Iterator<Item = &Inlay> {
265 self.inlay_map.current_inlays()
266 }
267
268 pub fn splice_inlays(
269 &mut self,
270 to_remove: Vec<InlayId>,
271 to_insert: Vec<Inlay>,
272 cx: &mut ModelContext<Self>,
273 ) {
274 if to_remove.is_empty() && to_insert.is_empty() {
275 return;
276 }
277 let buffer_snapshot = self.buffer.read(cx).snapshot(cx);
278 let edits = self.buffer_subscription.consume().into_inner();
279 let (snapshot, edits) = self.inlay_map.sync(buffer_snapshot, edits);
280 let (snapshot, edits) = self.fold_map.read(snapshot, edits);
281 let tab_size = Self::tab_size(&self.buffer, cx);
282 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
283 let (snapshot, edits) = self
284 .wrap_map
285 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
286 self.block_map.read(snapshot, edits);
287
288 let (snapshot, edits) = self.inlay_map.splice(to_remove, to_insert);
289 let (snapshot, edits) = self.fold_map.read(snapshot, edits);
290 let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
291 let (snapshot, edits) = self
292 .wrap_map
293 .update(cx, |map, cx| map.sync(snapshot, edits, cx));
294 self.block_map.read(snapshot, edits);
295 }
296
297 fn tab_size(buffer: &Model<MultiBuffer>, cx: &mut ModelContext<Self>) -> NonZeroU32 {
298 let language = buffer
299 .read(cx)
300 .as_singleton()
301 .and_then(|buffer| buffer.read(cx).language());
302 language_settings(language.as_deref(), None, cx).tab_size
303 }
304
305 #[cfg(test)]
306 pub fn is_rewrapping(&self, cx: &gpui::AppContext) -> bool {
307 self.wrap_map.read(cx).is_rewrapping()
308 }
309}
310
311#[derive(Debug, Default)]
312pub struct Highlights<'a> {
313 pub text_highlights: Option<&'a TextHighlights>,
314 pub inlay_highlights: Option<&'a InlayHighlights>,
315 pub inlay_highlight_style: Option<HighlightStyle>,
316 pub suggestion_highlight_style: Option<HighlightStyle>,
317}
318
319pub struct HighlightedChunk<'a> {
320 pub chunk: &'a str,
321 pub style: Option<HighlightStyle>,
322 pub is_tab: bool,
323}
324
325pub struct DisplaySnapshot {
326 pub buffer_snapshot: MultiBufferSnapshot,
327 pub fold_snapshot: fold_map::FoldSnapshot,
328 inlay_snapshot: inlay_map::InlaySnapshot,
329 tab_snapshot: tab_map::TabSnapshot,
330 wrap_snapshot: wrap_map::WrapSnapshot,
331 block_snapshot: block_map::BlockSnapshot,
332 text_highlights: TextHighlights,
333 inlay_highlights: InlayHighlights,
334 clip_at_line_ends: bool,
335}
336
337impl DisplaySnapshot {
338 #[cfg(test)]
339 pub fn fold_count(&self) -> usize {
340 self.fold_snapshot.fold_count()
341 }
342
343 pub fn is_empty(&self) -> bool {
344 self.buffer_snapshot.len() == 0
345 }
346
347 pub fn buffer_rows(&self, start_row: u32) -> DisplayBufferRows {
348 self.block_snapshot.buffer_rows(start_row)
349 }
350
351 pub fn max_buffer_row(&self) -> u32 {
352 self.buffer_snapshot.max_buffer_row()
353 }
354
355 pub fn prev_line_boundary(&self, mut point: Point) -> (Point, DisplayPoint) {
356 loop {
357 let mut inlay_point = self.inlay_snapshot.to_inlay_point(point);
358 let mut fold_point = self.fold_snapshot.to_fold_point(inlay_point, Bias::Left);
359 fold_point.0.column = 0;
360 inlay_point = fold_point.to_inlay_point(&self.fold_snapshot);
361 point = self.inlay_snapshot.to_buffer_point(inlay_point);
362
363 let mut display_point = self.point_to_display_point(point, Bias::Left);
364 *display_point.column_mut() = 0;
365 let next_point = self.display_point_to_point(display_point, Bias::Left);
366 if next_point == point {
367 return (point, display_point);
368 }
369 point = next_point;
370 }
371 }
372
373 pub fn next_line_boundary(&self, mut point: Point) -> (Point, DisplayPoint) {
374 loop {
375 let mut inlay_point = self.inlay_snapshot.to_inlay_point(point);
376 let mut fold_point = self.fold_snapshot.to_fold_point(inlay_point, Bias::Right);
377 fold_point.0.column = self.fold_snapshot.line_len(fold_point.row());
378 inlay_point = fold_point.to_inlay_point(&self.fold_snapshot);
379 point = self.inlay_snapshot.to_buffer_point(inlay_point);
380
381 let mut display_point = self.point_to_display_point(point, Bias::Right);
382 *display_point.column_mut() = self.line_len(display_point.row());
383 let next_point = self.display_point_to_point(display_point, Bias::Right);
384 if next_point == point {
385 return (point, display_point);
386 }
387 point = next_point;
388 }
389 }
390
391 // used by line_mode selections and tries to match vim behaviour
392 pub fn expand_to_line(&self, range: Range<Point>) -> Range<Point> {
393 let new_start = if range.start.row == 0 {
394 Point::new(0, 0)
395 } else if range.start.row == self.max_buffer_row()
396 || (range.end.column > 0 && range.end.row == self.max_buffer_row())
397 {
398 Point::new(range.start.row - 1, self.line_len(range.start.row - 1))
399 } else {
400 self.prev_line_boundary(range.start).0
401 };
402
403 let new_end = if range.end.column == 0 {
404 range.end
405 } else if range.end.row < self.max_buffer_row() {
406 self.buffer_snapshot
407 .clip_point(Point::new(range.end.row + 1, 0), Bias::Left)
408 } else {
409 self.buffer_snapshot.max_point()
410 };
411
412 new_start..new_end
413 }
414
415 fn point_to_display_point(&self, point: Point, bias: Bias) -> DisplayPoint {
416 let inlay_point = self.inlay_snapshot.to_inlay_point(point);
417 let fold_point = self.fold_snapshot.to_fold_point(inlay_point, bias);
418 let tab_point = self.tab_snapshot.to_tab_point(fold_point);
419 let wrap_point = self.wrap_snapshot.tab_point_to_wrap_point(tab_point);
420 let block_point = self.block_snapshot.to_block_point(wrap_point);
421 DisplayPoint(block_point)
422 }
423
424 fn display_point_to_point(&self, point: DisplayPoint, bias: Bias) -> Point {
425 self.inlay_snapshot
426 .to_buffer_point(self.display_point_to_inlay_point(point, bias))
427 }
428
429 pub fn display_point_to_inlay_offset(&self, point: DisplayPoint, bias: Bias) -> InlayOffset {
430 self.inlay_snapshot
431 .to_offset(self.display_point_to_inlay_point(point, bias))
432 }
433
434 pub fn anchor_to_inlay_offset(&self, anchor: Anchor) -> InlayOffset {
435 self.inlay_snapshot
436 .to_inlay_offset(anchor.to_offset(&self.buffer_snapshot))
437 }
438
439 fn display_point_to_inlay_point(&self, point: DisplayPoint, bias: Bias) -> InlayPoint {
440 let block_point = point.0;
441 let wrap_point = self.block_snapshot.to_wrap_point(block_point);
442 let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
443 let fold_point = self.tab_snapshot.to_fold_point(tab_point, bias).0;
444 fold_point.to_inlay_point(&self.fold_snapshot)
445 }
446
447 pub fn display_point_to_fold_point(&self, point: DisplayPoint, bias: Bias) -> FoldPoint {
448 let block_point = point.0;
449 let wrap_point = self.block_snapshot.to_wrap_point(block_point);
450 let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
451 self.tab_snapshot.to_fold_point(tab_point, bias).0
452 }
453
454 pub fn fold_point_to_display_point(&self, fold_point: FoldPoint) -> DisplayPoint {
455 let tab_point = self.tab_snapshot.to_tab_point(fold_point);
456 let wrap_point = self.wrap_snapshot.tab_point_to_wrap_point(tab_point);
457 let block_point = self.block_snapshot.to_block_point(wrap_point);
458 DisplayPoint(block_point)
459 }
460
461 pub fn max_point(&self) -> DisplayPoint {
462 DisplayPoint(self.block_snapshot.max_point())
463 }
464
465 /// Returns text chunks starting at the given display row until the end of the file
466 pub fn text_chunks(&self, display_row: u32) -> impl Iterator<Item = &str> {
467 self.block_snapshot
468 .chunks(
469 display_row..self.max_point().row() + 1,
470 false,
471 Highlights::default(),
472 )
473 .map(|h| h.text)
474 }
475
476 /// Returns text chunks starting at the end of the given display row in reverse until the start of the file
477 pub fn reverse_text_chunks(&self, display_row: u32) -> impl Iterator<Item = &str> {
478 (0..=display_row).into_iter().rev().flat_map(|row| {
479 self.block_snapshot
480 .chunks(row..row + 1, false, Highlights::default())
481 .map(|h| h.text)
482 .collect::<Vec<_>>()
483 .into_iter()
484 .rev()
485 })
486 }
487
488 pub fn chunks<'a>(
489 &'a self,
490 display_rows: Range<u32>,
491 language_aware: bool,
492 inlay_highlight_style: Option<HighlightStyle>,
493 suggestion_highlight_style: Option<HighlightStyle>,
494 ) -> DisplayChunks<'a> {
495 self.block_snapshot.chunks(
496 display_rows,
497 language_aware,
498 Highlights {
499 text_highlights: Some(&self.text_highlights),
500 inlay_highlights: Some(&self.inlay_highlights),
501 inlay_highlight_style,
502 suggestion_highlight_style,
503 },
504 )
505 }
506
507 pub fn highlighted_chunks<'a>(
508 &'a self,
509 display_rows: Range<u32>,
510 language_aware: bool,
511 editor_style: &'a EditorStyle,
512 ) -> impl Iterator<Item = HighlightedChunk<'a>> {
513 self.chunks(
514 display_rows,
515 language_aware,
516 Some(editor_style.inlays_style),
517 Some(editor_style.suggestions_style),
518 )
519 .map(|chunk| {
520 let mut highlight_style = chunk
521 .syntax_highlight_id
522 .and_then(|id| id.style(&editor_style.syntax));
523
524 if let Some(chunk_highlight) = chunk.highlight_style {
525 if let Some(highlight_style) = highlight_style.as_mut() {
526 highlight_style.highlight(chunk_highlight);
527 } else {
528 highlight_style = Some(chunk_highlight);
529 }
530 }
531
532 let mut diagnostic_highlight = HighlightStyle::default();
533
534 if chunk.is_unnecessary {
535 diagnostic_highlight.fade_out = Some(UNNECESSARY_CODE_FADE);
536 }
537
538 if let Some(severity) = chunk.diagnostic_severity {
539 // Omit underlines for HINT/INFO diagnostics on 'unnecessary' code.
540 if severity <= DiagnosticSeverity::WARNING || !chunk.is_unnecessary {
541 let diagnostic_color =
542 super::diagnostic_style(severity, true, &editor_style.diagnostic_style);
543 diagnostic_highlight.underline = Some(UnderlineStyle {
544 color: Some(diagnostic_color),
545 thickness: 1.0.into(),
546 wavy: true,
547 });
548 }
549 }
550
551 if let Some(highlight_style) = highlight_style.as_mut() {
552 highlight_style.highlight(diagnostic_highlight);
553 } else {
554 highlight_style = Some(diagnostic_highlight);
555 }
556
557 HighlightedChunk {
558 chunk: chunk.text,
559 style: highlight_style,
560 is_tab: chunk.is_tab,
561 }
562 })
563 }
564
565 pub fn layout_row(
566 &self,
567 display_row: u32,
568 TextLayoutDetails {
569 text_system,
570 editor_style,
571 rem_size,
572 }: &TextLayoutDetails,
573 ) -> Arc<LineLayout> {
574 let mut runs = Vec::new();
575 let mut line = String::new();
576
577 let range = display_row..display_row + 1;
578 for chunk in self.highlighted_chunks(range, false, &editor_style) {
579 line.push_str(chunk.chunk);
580
581 let text_style = if let Some(style) = chunk.style {
582 Cow::Owned(editor_style.text.clone().highlight(style))
583 } else {
584 Cow::Borrowed(&editor_style.text)
585 };
586
587 runs.push(text_style.to_run(chunk.chunk.len()))
588 }
589
590 if line.ends_with('\n') {
591 line.pop();
592 if let Some(last_run) = runs.last_mut() {
593 last_run.len -= 1;
594 if last_run.len == 0 {
595 runs.pop();
596 }
597 }
598 }
599
600 let font_size = editor_style.text.font_size.to_pixels(*rem_size);
601 text_system
602 .layout_line(&line, font_size, &runs)
603 .expect("we expect the font to be loaded because it's rendered by the editor")
604 }
605
606 pub fn x_for_display_point(
607 &self,
608 display_point: DisplayPoint,
609 text_layout_details: &TextLayoutDetails,
610 ) -> Pixels {
611 let line = self.layout_row(display_point.row(), text_layout_details);
612 line.x_for_index(display_point.column() as usize)
613 }
614
615 pub fn display_column_for_x(
616 &self,
617 display_row: u32,
618 x: Pixels,
619 details: &TextLayoutDetails,
620 ) -> u32 {
621 let layout_line = self.layout_row(display_row, details);
622 layout_line.closest_index_for_x(x) as u32
623 }
624
625 pub fn chars_at(
626 &self,
627 mut point: DisplayPoint,
628 ) -> impl Iterator<Item = (char, DisplayPoint)> + '_ {
629 point = DisplayPoint(self.block_snapshot.clip_point(point.0, Bias::Left));
630 self.text_chunks(point.row())
631 .flat_map(str::chars)
632 .skip_while({
633 let mut column = 0;
634 move |char| {
635 let at_point = column >= point.column();
636 column += char.len_utf8() as u32;
637 !at_point
638 }
639 })
640 .map(move |ch| {
641 let result = (ch, point);
642 if ch == '\n' {
643 *point.row_mut() += 1;
644 *point.column_mut() = 0;
645 } else {
646 *point.column_mut() += ch.len_utf8() as u32;
647 }
648 result
649 })
650 }
651
652 pub fn reverse_chars_at(
653 &self,
654 mut point: DisplayPoint,
655 ) -> impl Iterator<Item = (char, DisplayPoint)> + '_ {
656 point = DisplayPoint(self.block_snapshot.clip_point(point.0, Bias::Left));
657 self.reverse_text_chunks(point.row())
658 .flat_map(|chunk| chunk.chars().rev())
659 .skip_while({
660 let mut column = self.line_len(point.row());
661 if self.max_point().row() > point.row() {
662 column += 1;
663 }
664
665 move |char| {
666 let at_point = column <= point.column();
667 column = column.saturating_sub(char.len_utf8() as u32);
668 !at_point
669 }
670 })
671 .map(move |ch| {
672 if ch == '\n' {
673 *point.row_mut() -= 1;
674 *point.column_mut() = self.line_len(point.row());
675 } else {
676 *point.column_mut() = point.column().saturating_sub(ch.len_utf8() as u32);
677 }
678 (ch, point)
679 })
680 }
681
682 pub fn column_to_chars(&self, display_row: u32, target: u32) -> u32 {
683 let mut count = 0;
684 let mut column = 0;
685 for (c, _) in self.chars_at(DisplayPoint::new(display_row, 0)) {
686 if column >= target {
687 break;
688 }
689 count += 1;
690 column += c.len_utf8() as u32;
691 }
692 count
693 }
694
695 pub fn column_from_chars(&self, display_row: u32, char_count: u32) -> u32 {
696 let mut column = 0;
697
698 for (count, (c, _)) in self.chars_at(DisplayPoint::new(display_row, 0)).enumerate() {
699 if c == '\n' || count >= char_count as usize {
700 break;
701 }
702 column += c.len_utf8() as u32;
703 }
704
705 column
706 }
707
708 pub fn clip_point(&self, point: DisplayPoint, bias: Bias) -> DisplayPoint {
709 let mut clipped = self.block_snapshot.clip_point(point.0, bias);
710 if self.clip_at_line_ends {
711 clipped = self.clip_at_line_end(DisplayPoint(clipped)).0
712 }
713 DisplayPoint(clipped)
714 }
715
716 pub fn clip_at_line_end(&self, point: DisplayPoint) -> DisplayPoint {
717 let mut point = point.0;
718 if point.column == self.line_len(point.row) {
719 point.column = point.column.saturating_sub(1);
720 point = self.block_snapshot.clip_point(point, Bias::Left);
721 }
722 DisplayPoint(point)
723 }
724
725 pub fn folds_in_range<T>(&self, range: Range<T>) -> impl Iterator<Item = &Fold>
726 where
727 T: ToOffset,
728 {
729 self.fold_snapshot.folds_in_range(range)
730 }
731
732 pub fn blocks_in_range(
733 &self,
734 rows: Range<u32>,
735 ) -> impl Iterator<Item = (u32, &TransformBlock)> {
736 self.block_snapshot.blocks_in_range(rows)
737 }
738
739 pub fn intersects_fold<T: ToOffset>(&self, offset: T) -> bool {
740 self.fold_snapshot.intersects_fold(offset)
741 }
742
743 pub fn is_line_folded(&self, buffer_row: u32) -> bool {
744 self.fold_snapshot.is_line_folded(buffer_row)
745 }
746
747 pub fn is_block_line(&self, display_row: u32) -> bool {
748 self.block_snapshot.is_block_line(display_row)
749 }
750
751 pub fn soft_wrap_indent(&self, display_row: u32) -> Option<u32> {
752 let wrap_row = self
753 .block_snapshot
754 .to_wrap_point(BlockPoint::new(display_row, 0))
755 .row();
756 self.wrap_snapshot.soft_wrap_indent(wrap_row)
757 }
758
759 pub fn text(&self) -> String {
760 self.text_chunks(0).collect()
761 }
762
763 pub fn line(&self, display_row: u32) -> String {
764 let mut result = String::new();
765 for chunk in self.text_chunks(display_row) {
766 if let Some(ix) = chunk.find('\n') {
767 result.push_str(&chunk[0..ix]);
768 break;
769 } else {
770 result.push_str(chunk);
771 }
772 }
773 result
774 }
775
776 pub fn line_indent(&self, display_row: u32) -> (u32, bool) {
777 let mut indent = 0;
778 let mut is_blank = true;
779 for (c, _) in self.chars_at(DisplayPoint::new(display_row, 0)) {
780 if c == ' ' {
781 indent += 1;
782 } else {
783 is_blank = c == '\n';
784 break;
785 }
786 }
787 (indent, is_blank)
788 }
789
790 pub fn line_indent_for_buffer_row(&self, buffer_row: u32) -> (u32, bool) {
791 let (buffer, range) = self
792 .buffer_snapshot
793 .buffer_line_for_row(buffer_row)
794 .unwrap();
795
796 let mut indent_size = 0;
797 let mut is_blank = false;
798 for c in buffer.chars_at(Point::new(range.start.row, 0)) {
799 if c == ' ' || c == '\t' {
800 indent_size += 1;
801 } else {
802 if c == '\n' {
803 is_blank = true;
804 }
805 break;
806 }
807 }
808
809 (indent_size, is_blank)
810 }
811
812 pub fn line_len(&self, row: u32) -> u32 {
813 self.block_snapshot.line_len(row)
814 }
815
816 pub fn longest_row(&self) -> u32 {
817 self.block_snapshot.longest_row()
818 }
819
820 pub fn fold_for_line(self: &Self, buffer_row: u32) -> Option<FoldStatus> {
821 if self.is_line_folded(buffer_row) {
822 Some(FoldStatus::Folded)
823 } else if self.is_foldable(buffer_row) {
824 Some(FoldStatus::Foldable)
825 } else {
826 None
827 }
828 }
829
830 pub fn is_foldable(self: &Self, buffer_row: u32) -> bool {
831 let max_row = self.buffer_snapshot.max_buffer_row();
832 if buffer_row >= max_row {
833 return false;
834 }
835
836 let (indent_size, is_blank) = self.line_indent_for_buffer_row(buffer_row);
837 if is_blank {
838 return false;
839 }
840
841 for next_row in (buffer_row + 1)..=max_row {
842 let (next_indent_size, next_line_is_blank) = self.line_indent_for_buffer_row(next_row);
843 if next_indent_size > indent_size {
844 return true;
845 } else if !next_line_is_blank {
846 break;
847 }
848 }
849
850 false
851 }
852
853 pub fn foldable_range(self: &Self, buffer_row: u32) -> Option<Range<Point>> {
854 let start = Point::new(buffer_row, self.buffer_snapshot.line_len(buffer_row));
855 if self.is_foldable(start.row) && !self.is_line_folded(start.row) {
856 let (start_indent, _) = self.line_indent_for_buffer_row(buffer_row);
857 let max_point = self.buffer_snapshot.max_point();
858 let mut end = None;
859
860 for row in (buffer_row + 1)..=max_point.row {
861 let (indent, is_blank) = self.line_indent_for_buffer_row(row);
862 if !is_blank && indent <= start_indent {
863 let prev_row = row - 1;
864 end = Some(Point::new(
865 prev_row,
866 self.buffer_snapshot.line_len(prev_row),
867 ));
868 break;
869 }
870 }
871 let end = end.unwrap_or(max_point);
872 Some(start..end)
873 } else {
874 None
875 }
876 }
877
878 #[cfg(any(test, feature = "test-support"))]
879 pub fn text_highlight_ranges<Tag: ?Sized + 'static>(
880 &self,
881 ) -> Option<Arc<(HighlightStyle, Vec<Range<Anchor>>)>> {
882 let type_id = TypeId::of::<Tag>();
883 self.text_highlights.get(&Some(type_id)).cloned()
884 }
885
886 #[cfg(any(test, feature = "test-support"))]
887 pub fn inlay_highlights<Tag: ?Sized + 'static>(
888 &self,
889 ) -> Option<&HashMap<InlayId, (HighlightStyle, InlayHighlight)>> {
890 let type_id = TypeId::of::<Tag>();
891 self.inlay_highlights.get(&type_id)
892 }
893}
894
895#[derive(Copy, Clone, Default, Eq, Ord, PartialOrd, PartialEq)]
896pub struct DisplayPoint(BlockPoint);
897
898impl Debug for DisplayPoint {
899 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
900 f.write_fmt(format_args!(
901 "DisplayPoint({}, {})",
902 self.row(),
903 self.column()
904 ))
905 }
906}
907
908impl DisplayPoint {
909 pub fn new(row: u32, column: u32) -> Self {
910 Self(BlockPoint(Point::new(row, column)))
911 }
912
913 pub fn zero() -> Self {
914 Self::new(0, 0)
915 }
916
917 pub fn is_zero(&self) -> bool {
918 self.0.is_zero()
919 }
920
921 pub fn row(self) -> u32 {
922 self.0.row
923 }
924
925 pub fn column(self) -> u32 {
926 self.0.column
927 }
928
929 pub fn row_mut(&mut self) -> &mut u32 {
930 &mut self.0.row
931 }
932
933 pub fn column_mut(&mut self) -> &mut u32 {
934 &mut self.0.column
935 }
936
937 pub fn to_point(self, map: &DisplaySnapshot) -> Point {
938 map.display_point_to_point(self, Bias::Left)
939 }
940
941 pub fn to_offset(self, map: &DisplaySnapshot, bias: Bias) -> usize {
942 let wrap_point = map.block_snapshot.to_wrap_point(self.0);
943 let tab_point = map.wrap_snapshot.to_tab_point(wrap_point);
944 let fold_point = map.tab_snapshot.to_fold_point(tab_point, bias).0;
945 let inlay_point = fold_point.to_inlay_point(&map.fold_snapshot);
946 map.inlay_snapshot
947 .to_buffer_offset(map.inlay_snapshot.to_offset(inlay_point))
948 }
949}
950
951impl ToDisplayPoint for usize {
952 fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint {
953 map.point_to_display_point(self.to_point(&map.buffer_snapshot), Bias::Left)
954 }
955}
956
957impl ToDisplayPoint for OffsetUtf16 {
958 fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint {
959 self.to_offset(&map.buffer_snapshot).to_display_point(map)
960 }
961}
962
963impl ToDisplayPoint for Point {
964 fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint {
965 map.point_to_display_point(*self, Bias::Left)
966 }
967}
968
969impl ToDisplayPoint for Anchor {
970 fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint {
971 self.to_point(&map.buffer_snapshot).to_display_point(map)
972 }
973}
974
975pub fn next_rows(display_row: u32, display_map: &DisplaySnapshot) -> impl Iterator<Item = u32> {
976 let max_row = display_map.max_point().row();
977 let start_row = display_row + 1;
978 let mut current = None;
979 std::iter::from_fn(move || {
980 if current == None {
981 current = Some(start_row);
982 } else {
983 current = Some(current.unwrap() + 1)
984 }
985 if current.unwrap() > max_row {
986 None
987 } else {
988 current
989 }
990 })
991}
992
993#[cfg(test)]
994pub mod tests {
995 use super::*;
996 use crate::{
997 movement,
998 test::{editor_test_context::EditorTestContext, marked_display_snapshot},
999 };
1000 use gpui::{div, font, observe, px, AppContext, Context, Element, Hsla};
1001 use language::{
1002 language_settings::{AllLanguageSettings, AllLanguageSettingsContent},
1003 Buffer, Language, LanguageConfig, SelectionGoal,
1004 };
1005 use project::Project;
1006 use rand::{prelude::*, Rng};
1007 use settings::SettingsStore;
1008 use smol::stream::StreamExt;
1009 use std::{env, sync::Arc};
1010 use theme::{LoadThemes, SyntaxTheme};
1011 use util::test::{marked_text_ranges, sample_text};
1012 use Bias::*;
1013
1014 #[gpui::test(iterations = 100)]
1015 async fn test_random_display_map(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
1016 cx.background_executor.set_block_on_ticks(0..=50);
1017 let operations = env::var("OPERATIONS")
1018 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1019 .unwrap_or(10);
1020
1021 let test_platform = &cx.test_platform;
1022 let mut tab_size = rng.gen_range(1..=4);
1023 let buffer_start_excerpt_header_height = rng.gen_range(1..=5);
1024 let excerpt_header_height = rng.gen_range(1..=5);
1025 let font_size = px(14.0);
1026 let max_wrap_width = 300.0;
1027 let mut wrap_width = if rng.gen_bool(0.1) {
1028 None
1029 } else {
1030 Some(px(rng.gen_range(0.0..=max_wrap_width)))
1031 };
1032
1033 log::info!("tab size: {}", tab_size);
1034 log::info!("wrap width: {:?}", wrap_width);
1035
1036 cx.update(|cx| {
1037 init_test(cx, |s| s.defaults.tab_size = NonZeroU32::new(tab_size));
1038 });
1039
1040 let buffer = cx.update(|cx| {
1041 if rng.gen() {
1042 let len = rng.gen_range(0..10);
1043 let text = util::RandomCharIter::new(&mut rng)
1044 .take(len)
1045 .collect::<String>();
1046 MultiBuffer::build_simple(&text, cx)
1047 } else {
1048 MultiBuffer::build_random(&mut rng, cx)
1049 }
1050 });
1051
1052 let map = cx.build_model(|cx| {
1053 DisplayMap::new(
1054 buffer.clone(),
1055 font("Helvetica"),
1056 font_size,
1057 wrap_width,
1058 buffer_start_excerpt_header_height,
1059 excerpt_header_height,
1060 cx,
1061 )
1062 });
1063 let mut notifications = observe(&map, cx);
1064 let mut fold_count = 0;
1065 let mut blocks = Vec::new();
1066
1067 let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
1068 log::info!("buffer text: {:?}", snapshot.buffer_snapshot.text());
1069 log::info!("fold text: {:?}", snapshot.fold_snapshot.text());
1070 log::info!("tab text: {:?}", snapshot.tab_snapshot.text());
1071 log::info!("wrap text: {:?}", snapshot.wrap_snapshot.text());
1072 log::info!("block text: {:?}", snapshot.block_snapshot.text());
1073 log::info!("display text: {:?}", snapshot.text());
1074
1075 for _i in 0..operations {
1076 match rng.gen_range(0..100) {
1077 0..=19 => {
1078 wrap_width = if rng.gen_bool(0.2) {
1079 None
1080 } else {
1081 Some(px(rng.gen_range(0.0..=max_wrap_width)))
1082 };
1083 log::info!("setting wrap width to {:?}", wrap_width);
1084 map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1085 }
1086 20..=29 => {
1087 let mut tab_sizes = vec![1, 2, 3, 4];
1088 tab_sizes.remove((tab_size - 1) as usize);
1089 tab_size = *tab_sizes.choose(&mut rng).unwrap();
1090 log::info!("setting tab size to {:?}", tab_size);
1091 cx.update(|cx| {
1092 cx.update_global::<SettingsStore, _>(|store, cx| {
1093 store.update_user_settings::<AllLanguageSettings>(cx, |s| {
1094 s.defaults.tab_size = NonZeroU32::new(tab_size);
1095 });
1096 });
1097 });
1098 }
1099 30..=44 => {
1100 map.update(cx, |map, cx| {
1101 if rng.gen() || blocks.is_empty() {
1102 let buffer = map.snapshot(cx).buffer_snapshot;
1103 let block_properties = (0..rng.gen_range(1..=1))
1104 .map(|_| {
1105 let position =
1106 buffer.anchor_after(buffer.clip_offset(
1107 rng.gen_range(0..=buffer.len()),
1108 Bias::Left,
1109 ));
1110
1111 let disposition = if rng.gen() {
1112 BlockDisposition::Above
1113 } else {
1114 BlockDisposition::Below
1115 };
1116 let height = rng.gen_range(1..5);
1117 log::info!(
1118 "inserting block {:?} {:?} with height {}",
1119 disposition,
1120 position.to_point(&buffer),
1121 height
1122 );
1123 BlockProperties {
1124 style: BlockStyle::Fixed,
1125 position,
1126 height,
1127 disposition,
1128 render: Arc::new(|_| div().into_any()),
1129 }
1130 })
1131 .collect::<Vec<_>>();
1132 blocks.extend(map.insert_blocks(block_properties, cx));
1133 } else {
1134 blocks.shuffle(&mut rng);
1135 let remove_count = rng.gen_range(1..=4.min(blocks.len()));
1136 let block_ids_to_remove = (0..remove_count)
1137 .map(|_| blocks.remove(rng.gen_range(0..blocks.len())))
1138 .collect();
1139 log::info!("removing block ids {:?}", block_ids_to_remove);
1140 map.remove_blocks(block_ids_to_remove, cx);
1141 }
1142 });
1143 }
1144 45..=79 => {
1145 let mut ranges = Vec::new();
1146 for _ in 0..rng.gen_range(1..=3) {
1147 buffer.read_with(cx, |buffer, cx| {
1148 let buffer = buffer.read(cx);
1149 let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
1150 let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
1151 ranges.push(start..end);
1152 });
1153 }
1154
1155 if rng.gen() && fold_count > 0 {
1156 log::info!("unfolding ranges: {:?}", ranges);
1157 map.update(cx, |map, cx| {
1158 map.unfold(ranges, true, cx);
1159 });
1160 } else {
1161 log::info!("folding ranges: {:?}", ranges);
1162 map.update(cx, |map, cx| {
1163 map.fold(ranges, cx);
1164 });
1165 }
1166 }
1167 _ => {
1168 buffer.update(cx, |buffer, cx| buffer.randomly_mutate(&mut rng, 5, cx));
1169 }
1170 }
1171
1172 if map.read_with(cx, |map, cx| map.is_rewrapping(cx)) {
1173 notifications.next().await.unwrap();
1174 }
1175
1176 let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
1177 fold_count = snapshot.fold_count();
1178 log::info!("buffer text: {:?}", snapshot.buffer_snapshot.text());
1179 log::info!("fold text: {:?}", snapshot.fold_snapshot.text());
1180 log::info!("tab text: {:?}", snapshot.tab_snapshot.text());
1181 log::info!("wrap text: {:?}", snapshot.wrap_snapshot.text());
1182 log::info!("block text: {:?}", snapshot.block_snapshot.text());
1183 log::info!("display text: {:?}", snapshot.text());
1184
1185 // Line boundaries
1186 let buffer = &snapshot.buffer_snapshot;
1187 for _ in 0..5 {
1188 let row = rng.gen_range(0..=buffer.max_point().row);
1189 let column = rng.gen_range(0..=buffer.line_len(row));
1190 let point = buffer.clip_point(Point::new(row, column), Left);
1191
1192 let (prev_buffer_bound, prev_display_bound) = snapshot.prev_line_boundary(point);
1193 let (next_buffer_bound, next_display_bound) = snapshot.next_line_boundary(point);
1194
1195 assert!(prev_buffer_bound <= point);
1196 assert!(next_buffer_bound >= point);
1197 assert_eq!(prev_buffer_bound.column, 0);
1198 assert_eq!(prev_display_bound.column(), 0);
1199 if next_buffer_bound < buffer.max_point() {
1200 assert_eq!(buffer.chars_at(next_buffer_bound).next(), Some('\n'));
1201 }
1202
1203 assert_eq!(
1204 prev_display_bound,
1205 prev_buffer_bound.to_display_point(&snapshot),
1206 "row boundary before {:?}. reported buffer row boundary: {:?}",
1207 point,
1208 prev_buffer_bound
1209 );
1210 assert_eq!(
1211 next_display_bound,
1212 next_buffer_bound.to_display_point(&snapshot),
1213 "display row boundary after {:?}. reported buffer row boundary: {:?}",
1214 point,
1215 next_buffer_bound
1216 );
1217 assert_eq!(
1218 prev_buffer_bound,
1219 prev_display_bound.to_point(&snapshot),
1220 "row boundary before {:?}. reported display row boundary: {:?}",
1221 point,
1222 prev_display_bound
1223 );
1224 assert_eq!(
1225 next_buffer_bound,
1226 next_display_bound.to_point(&snapshot),
1227 "row boundary after {:?}. reported display row boundary: {:?}",
1228 point,
1229 next_display_bound
1230 );
1231 }
1232
1233 // Movement
1234 let min_point = snapshot.clip_point(DisplayPoint::new(0, 0), Left);
1235 let max_point = snapshot.clip_point(snapshot.max_point(), Right);
1236 for _ in 0..5 {
1237 let row = rng.gen_range(0..=snapshot.max_point().row());
1238 let column = rng.gen_range(0..=snapshot.line_len(row));
1239 let point = snapshot.clip_point(DisplayPoint::new(row, column), Left);
1240
1241 log::info!("Moving from point {:?}", point);
1242
1243 let moved_right = movement::right(&snapshot, point);
1244 log::info!("Right {:?}", moved_right);
1245 if point < max_point {
1246 assert!(moved_right > point);
1247 if point.column() == snapshot.line_len(point.row())
1248 || snapshot.soft_wrap_indent(point.row()).is_some()
1249 && point.column() == snapshot.line_len(point.row()) - 1
1250 {
1251 assert!(moved_right.row() > point.row());
1252 }
1253 } else {
1254 assert_eq!(moved_right, point);
1255 }
1256
1257 let moved_left = movement::left(&snapshot, point);
1258 log::info!("Left {:?}", moved_left);
1259 if point > min_point {
1260 assert!(moved_left < point);
1261 if point.column() == 0 {
1262 assert!(moved_left.row() < point.row());
1263 }
1264 } else {
1265 assert_eq!(moved_left, point);
1266 }
1267 }
1268 }
1269 }
1270
1271 #[gpui::test(retries = 5)]
1272 async fn test_soft_wraps(cx: &mut gpui::TestAppContext) {
1273 cx.background_executor
1274 .set_block_on_ticks(usize::MAX..=usize::MAX);
1275 cx.update(|cx| {
1276 init_test(cx, |_| {});
1277 });
1278
1279 let mut cx = EditorTestContext::new(cx).await;
1280 let editor = cx.editor.clone();
1281 let window = cx.window.clone();
1282
1283 cx.update_window(window, |_, cx| {
1284 let text_layout_details =
1285 editor.update(cx, |editor, cx| editor.text_layout_details(cx));
1286
1287 let font_size = px(12.0);
1288 let wrap_width = Some(px(64.));
1289
1290 let text = "one two three four five\nsix seven eight";
1291 let buffer = MultiBuffer::build_simple(text, cx);
1292 let map = cx.build_model(|cx| {
1293 DisplayMap::new(
1294 buffer.clone(),
1295 font("Helvetica"),
1296 font_size,
1297 wrap_width,
1298 1,
1299 1,
1300 cx,
1301 )
1302 });
1303
1304 let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
1305 assert_eq!(
1306 snapshot.text_chunks(0).collect::<String>(),
1307 "one two \nthree four \nfive\nsix seven \neight"
1308 );
1309 assert_eq!(
1310 snapshot.clip_point(DisplayPoint::new(0, 8), Bias::Left),
1311 DisplayPoint::new(0, 7)
1312 );
1313 assert_eq!(
1314 snapshot.clip_point(DisplayPoint::new(0, 8), Bias::Right),
1315 DisplayPoint::new(1, 0)
1316 );
1317 assert_eq!(
1318 movement::right(&snapshot, DisplayPoint::new(0, 7)),
1319 DisplayPoint::new(1, 0)
1320 );
1321 assert_eq!(
1322 movement::left(&snapshot, DisplayPoint::new(1, 0)),
1323 DisplayPoint::new(0, 7)
1324 );
1325
1326 let x = snapshot.x_for_display_point(DisplayPoint::new(1, 10), &text_layout_details);
1327 assert_eq!(
1328 movement::up(
1329 &snapshot,
1330 DisplayPoint::new(1, 10),
1331 SelectionGoal::None,
1332 false,
1333 &text_layout_details,
1334 ),
1335 (
1336 DisplayPoint::new(0, 7),
1337 SelectionGoal::HorizontalPosition(x.0)
1338 )
1339 );
1340 assert_eq!(
1341 movement::down(
1342 &snapshot,
1343 DisplayPoint::new(0, 7),
1344 SelectionGoal::HorizontalPosition(x.0),
1345 false,
1346 &text_layout_details
1347 ),
1348 (
1349 DisplayPoint::new(1, 10),
1350 SelectionGoal::HorizontalPosition(x.0)
1351 )
1352 );
1353 assert_eq!(
1354 movement::down(
1355 &snapshot,
1356 DisplayPoint::new(1, 10),
1357 SelectionGoal::HorizontalPosition(x.0),
1358 false,
1359 &text_layout_details
1360 ),
1361 (
1362 DisplayPoint::new(2, 4),
1363 SelectionGoal::HorizontalPosition(x.0)
1364 )
1365 );
1366
1367 let ix = snapshot.buffer_snapshot.text().find("seven").unwrap();
1368 buffer.update(cx, |buffer, cx| {
1369 buffer.edit([(ix..ix, "and ")], None, cx);
1370 });
1371
1372 let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
1373 assert_eq!(
1374 snapshot.text_chunks(1).collect::<String>(),
1375 "three four \nfive\nsix and \nseven eight"
1376 );
1377
1378 // Re-wrap on font size changes
1379 map.update(cx, |map, cx| {
1380 map.set_font(font("Helvetica"), px(font_size.0 + 3.), cx)
1381 });
1382
1383 let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
1384 assert_eq!(
1385 snapshot.text_chunks(1).collect::<String>(),
1386 "three \nfour five\nsix and \nseven \neight"
1387 )
1388 });
1389 }
1390
1391 #[gpui::test]
1392 fn test_text_chunks(cx: &mut gpui::AppContext) {
1393 init_test(cx, |_| {});
1394
1395 let text = sample_text(6, 6, 'a');
1396 let buffer = MultiBuffer::build_simple(&text, cx);
1397
1398 let font_size = px(14.0);
1399 let map = cx.build_model(|cx| {
1400 DisplayMap::new(buffer.clone(), font("Helvetica"), font_size, None, 1, 1, cx)
1401 });
1402
1403 buffer.update(cx, |buffer, cx| {
1404 buffer.edit(
1405 vec![
1406 (Point::new(1, 0)..Point::new(1, 0), "\t"),
1407 (Point::new(1, 1)..Point::new(1, 1), "\t"),
1408 (Point::new(2, 1)..Point::new(2, 1), "\t"),
1409 ],
1410 None,
1411 cx,
1412 )
1413 });
1414
1415 assert_eq!(
1416 map.update(cx, |map, cx| map.snapshot(cx))
1417 .text_chunks(1)
1418 .collect::<String>()
1419 .lines()
1420 .next(),
1421 Some(" b bbbbb")
1422 );
1423 assert_eq!(
1424 map.update(cx, |map, cx| map.snapshot(cx))
1425 .text_chunks(2)
1426 .collect::<String>()
1427 .lines()
1428 .next(),
1429 Some("c ccccc")
1430 );
1431 }
1432
1433 #[gpui::test]
1434 async fn test_chunks(cx: &mut gpui::TestAppContext) {
1435 use unindent::Unindent as _;
1436
1437 let text = r#"
1438 fn outer() {}
1439
1440 mod module {
1441 fn inner() {}
1442 }"#
1443 .unindent();
1444
1445 let theme = SyntaxTheme::new_test(vec![
1446 ("mod.body", Hsla::red().into()),
1447 ("fn.name", Hsla::blue().into()),
1448 ]);
1449 let language = Arc::new(
1450 Language::new(
1451 LanguageConfig {
1452 name: "Test".into(),
1453 path_suffixes: vec![".test".to_string()],
1454 ..Default::default()
1455 },
1456 Some(tree_sitter_rust::language()),
1457 )
1458 .with_highlights_query(
1459 r#"
1460 (mod_item name: (identifier) body: _ @mod.body)
1461 (function_item name: (identifier) @fn.name)
1462 "#,
1463 )
1464 .unwrap(),
1465 );
1466 language.set_theme(&theme);
1467
1468 cx.update(|cx| init_test(cx, |s| s.defaults.tab_size = Some(2.try_into().unwrap())));
1469
1470 let buffer = cx.build_model(|cx| {
1471 Buffer::new(0, cx.entity_id().as_u64(), text).with_language(language, cx)
1472 });
1473 cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
1474 let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
1475
1476 let font_size = px(14.0);
1477
1478 let map = cx.build_model(|cx| {
1479 DisplayMap::new(buffer, font("Helvetica"), font_size, None, 1, 1, cx)
1480 });
1481 assert_eq!(
1482 cx.update(|cx| syntax_chunks(0..5, &map, &theme, cx)),
1483 vec![
1484 ("fn ".to_string(), None),
1485 ("outer".to_string(), Some(Hsla::blue())),
1486 ("() {}\n\nmod module ".to_string(), None),
1487 ("{\n fn ".to_string(), Some(Hsla::red())),
1488 ("inner".to_string(), Some(Hsla::blue())),
1489 ("() {}\n}".to_string(), Some(Hsla::red())),
1490 ]
1491 );
1492 assert_eq!(
1493 cx.update(|cx| syntax_chunks(3..5, &map, &theme, cx)),
1494 vec![
1495 (" fn ".to_string(), Some(Hsla::red())),
1496 ("inner".to_string(), Some(Hsla::blue())),
1497 ("() {}\n}".to_string(), Some(Hsla::red())),
1498 ]
1499 );
1500
1501 map.update(cx, |map, cx| {
1502 map.fold(vec![Point::new(0, 6)..Point::new(3, 2)], cx)
1503 });
1504 assert_eq!(
1505 cx.update(|cx| syntax_chunks(0..2, &map, &theme, cx)),
1506 vec![
1507 ("fn ".to_string(), None),
1508 ("out".to_string(), Some(Hsla::blue())),
1509 ("āÆ".to_string(), None),
1510 (" fn ".to_string(), Some(Hsla::red())),
1511 ("inner".to_string(), Some(Hsla::blue())),
1512 ("() {}\n}".to_string(), Some(Hsla::red())),
1513 ]
1514 );
1515 }
1516
1517 #[gpui::test]
1518 async fn test_chunks_with_soft_wrapping(cx: &mut gpui::TestAppContext) {
1519 use unindent::Unindent as _;
1520
1521 cx.background_executor
1522 .set_block_on_ticks(usize::MAX..=usize::MAX);
1523
1524 let text = r#"
1525 fn outer() {}
1526
1527 mod module {
1528 fn inner() {}
1529 }"#
1530 .unindent();
1531
1532 let theme = SyntaxTheme::new_test(vec![
1533 ("mod.body", Hsla::red().into()),
1534 ("fn.name", Hsla::blue().into()),
1535 ]);
1536 let language = Arc::new(
1537 Language::new(
1538 LanguageConfig {
1539 name: "Test".into(),
1540 path_suffixes: vec![".test".to_string()],
1541 ..Default::default()
1542 },
1543 Some(tree_sitter_rust::language()),
1544 )
1545 .with_highlights_query(
1546 r#"
1547 (mod_item name: (identifier) body: _ @mod.body)
1548 (function_item name: (identifier) @fn.name)
1549 "#,
1550 )
1551 .unwrap(),
1552 );
1553 language.set_theme(&theme);
1554
1555 cx.update(|cx| init_test(cx, |_| {}));
1556
1557 let buffer = cx.build_model(|cx| {
1558 Buffer::new(0, cx.entity_id().as_u64(), text).with_language(language, cx)
1559 });
1560 cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
1561 let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
1562
1563 let font_size = px(16.0);
1564
1565 let map = cx.build_model(|cx| {
1566 DisplayMap::new(buffer, font("Courier"), font_size, Some(px(40.0)), 1, 1, cx)
1567 });
1568 assert_eq!(
1569 cx.update(|cx| syntax_chunks(0..5, &map, &theme, cx)),
1570 [
1571 ("fn \n".to_string(), None),
1572 ("oute\nr".to_string(), Some(Hsla::blue())),
1573 ("() \n{}\n\n".to_string(), None),
1574 ]
1575 );
1576 assert_eq!(
1577 cx.update(|cx| syntax_chunks(3..5, &map, &theme, cx)),
1578 [("{}\n\n".to_string(), None)]
1579 );
1580
1581 map.update(cx, |map, cx| {
1582 map.fold(vec![Point::new(0, 6)..Point::new(3, 2)], cx)
1583 });
1584 assert_eq!(
1585 cx.update(|cx| syntax_chunks(1..4, &map, &theme, cx)),
1586 [
1587 ("out".to_string(), Some(Hsla::blue())),
1588 ("āÆ\n".to_string(), None),
1589 (" \nfn ".to_string(), Some(Hsla::red())),
1590 ("i\n".to_string(), Some(Hsla::blue()))
1591 ]
1592 );
1593 }
1594
1595 #[gpui::test]
1596 async fn test_chunks_with_text_highlights(cx: &mut gpui::TestAppContext) {
1597 cx.update(|cx| init_test(cx, |_| {}));
1598
1599 let theme = SyntaxTheme::new_test(vec![
1600 ("operator", Hsla::red().into()),
1601 ("string", Hsla::green().into()),
1602 ]);
1603 let language = Arc::new(
1604 Language::new(
1605 LanguageConfig {
1606 name: "Test".into(),
1607 path_suffixes: vec![".test".to_string()],
1608 ..Default::default()
1609 },
1610 Some(tree_sitter_rust::language()),
1611 )
1612 .with_highlights_query(
1613 r#"
1614 ":" @operator
1615 (string_literal) @string
1616 "#,
1617 )
1618 .unwrap(),
1619 );
1620 language.set_theme(&theme);
1621
1622 let (text, highlighted_ranges) = marked_text_ranges(r#"constĖ Ā«aĀ»: B = "c Ā«dĀ»""#, false);
1623
1624 let buffer = cx.build_model(|cx| {
1625 Buffer::new(0, cx.entity_id().as_u64(), text).with_language(language, cx)
1626 });
1627 cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
1628
1629 let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
1630 let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
1631
1632 let font_size = px(16.0);
1633 let map = cx
1634 .build_model(|cx| DisplayMap::new(buffer, font("Courier"), font_size, None, 1, 1, cx));
1635
1636 enum MyType {}
1637
1638 let style = HighlightStyle {
1639 color: Some(Hsla::blue()),
1640 ..Default::default()
1641 };
1642
1643 map.update(cx, |map, _cx| {
1644 map.highlight_text(
1645 TypeId::of::<MyType>(),
1646 highlighted_ranges
1647 .into_iter()
1648 .map(|range| {
1649 buffer_snapshot.anchor_before(range.start)
1650 ..buffer_snapshot.anchor_before(range.end)
1651 })
1652 .collect(),
1653 style,
1654 );
1655 });
1656
1657 assert_eq!(
1658 cx.update(|cx| chunks(0..10, &map, &theme, cx)),
1659 [
1660 ("const ".to_string(), None, None),
1661 ("a".to_string(), None, Some(Hsla::blue())),
1662 (":".to_string(), Some(Hsla::red()), None),
1663 (" B = ".to_string(), None, None),
1664 ("\"c ".to_string(), Some(Hsla::green()), None),
1665 ("d".to_string(), Some(Hsla::green()), Some(Hsla::blue())),
1666 ("\"".to_string(), Some(Hsla::green()), None),
1667 ]
1668 );
1669 }
1670
1671 #[gpui::test]
1672 fn test_clip_point(cx: &mut gpui::AppContext) {
1673 init_test(cx, |_| {});
1674
1675 fn assert(text: &str, shift_right: bool, bias: Bias, cx: &mut gpui::AppContext) {
1676 let (unmarked_snapshot, mut markers) = marked_display_snapshot(text, cx);
1677
1678 match bias {
1679 Bias::Left => {
1680 if shift_right {
1681 *markers[1].column_mut() += 1;
1682 }
1683
1684 assert_eq!(unmarked_snapshot.clip_point(markers[1], bias), markers[0])
1685 }
1686 Bias::Right => {
1687 if shift_right {
1688 *markers[0].column_mut() += 1;
1689 }
1690
1691 assert_eq!(unmarked_snapshot.clip_point(markers[0], bias), markers[1])
1692 }
1693 };
1694 }
1695
1696 use Bias::{Left, Right};
1697 assert("ĖĖĪ±", false, Left, cx);
1698 assert("ĖĖĪ±", true, Left, cx);
1699 assert("ĖĖĪ±", false, Right, cx);
1700 assert("ĖĪ±Ė", true, Right, cx);
1701 assert("ĖĖā", false, Left, cx);
1702 assert("ĖĖā", true, Left, cx);
1703 assert("ĖĖā", false, Right, cx);
1704 assert("ĖāĖ", true, Right, cx);
1705 assert("ĖĖš", false, Left, cx);
1706 assert("ĖĖš", true, Left, cx);
1707 assert("ĖĖš", false, Right, cx);
1708 assert("ĖšĖ", true, Right, cx);
1709 assert("ĖĖ\t", false, Left, cx);
1710 assert("ĖĖ\t", true, Left, cx);
1711 assert("ĖĖ\t", false, Right, cx);
1712 assert("Ė\tĖ", true, Right, cx);
1713 assert(" ĖĖ\t", false, Left, cx);
1714 assert(" ĖĖ\t", true, Left, cx);
1715 assert(" ĖĖ\t", false, Right, cx);
1716 assert(" Ė\tĖ", true, Right, cx);
1717 assert(" ĖĖ\t", false, Left, cx);
1718 assert(" ĖĖ\t", false, Right, cx);
1719 }
1720
1721 #[gpui::test]
1722 fn test_clip_at_line_ends(cx: &mut gpui::AppContext) {
1723 init_test(cx, |_| {});
1724
1725 fn assert(text: &str, cx: &mut gpui::AppContext) {
1726 let (mut unmarked_snapshot, markers) = marked_display_snapshot(text, cx);
1727 unmarked_snapshot.clip_at_line_ends = true;
1728 assert_eq!(
1729 unmarked_snapshot.clip_point(markers[1], Bias::Left),
1730 markers[0]
1731 );
1732 }
1733
1734 assert("ĖĖ", cx);
1735 assert("ĖaĖ", cx);
1736 assert("aĖbĖ", cx);
1737 assert("aĖĪ±Ė", cx);
1738 }
1739
1740 #[gpui::test]
1741 fn test_tabs_with_multibyte_chars(cx: &mut gpui::AppContext) {
1742 init_test(cx, |_| {});
1743
1744 let text = "ā
\t\tĪ±\nĪ²\t\nšĪ²\t\tĪ³";
1745 let buffer = MultiBuffer::build_simple(text, cx);
1746 let font_size = px(14.0);
1747
1748 let map = cx.build_model(|cx| {
1749 DisplayMap::new(buffer.clone(), font("Helvetica"), font_size, None, 1, 1, cx)
1750 });
1751 let map = map.update(cx, |map, cx| map.snapshot(cx));
1752 assert_eq!(map.text(), "ā
Ī±\nĪ² \nšĪ² Ī³");
1753 assert_eq!(
1754 map.text_chunks(0).collect::<String>(),
1755 "ā
Ī±\nĪ² \nšĪ² Ī³"
1756 );
1757 assert_eq!(map.text_chunks(1).collect::<String>(), "Ī² \nšĪ² Ī³");
1758 assert_eq!(map.text_chunks(2).collect::<String>(), "šĪ² Ī³");
1759
1760 let point = Point::new(0, "ā
\t\t".len() as u32);
1761 let display_point = DisplayPoint::new(0, "ā
".len() as u32);
1762 assert_eq!(point.to_display_point(&map), display_point);
1763 assert_eq!(display_point.to_point(&map), point);
1764
1765 let point = Point::new(1, "Ī²\t".len() as u32);
1766 let display_point = DisplayPoint::new(1, "Ī² ".len() as u32);
1767 assert_eq!(point.to_display_point(&map), display_point);
1768 assert_eq!(display_point.to_point(&map), point,);
1769
1770 let point = Point::new(2, "šĪ²\t\t".len() as u32);
1771 let display_point = DisplayPoint::new(2, "šĪ² ".len() as u32);
1772 assert_eq!(point.to_display_point(&map), display_point);
1773 assert_eq!(display_point.to_point(&map), point,);
1774
1775 // Display points inside of expanded tabs
1776 assert_eq!(
1777 DisplayPoint::new(0, "ā
".len() as u32).to_point(&map),
1778 Point::new(0, "ā
\t".len() as u32),
1779 );
1780 assert_eq!(
1781 DisplayPoint::new(0, "ā
".len() as u32).to_point(&map),
1782 Point::new(0, "ā
".len() as u32),
1783 );
1784
1785 // Clipping display points inside of multi-byte characters
1786 assert_eq!(
1787 map.clip_point(DisplayPoint::new(0, "ā
".len() as u32 - 1), Left),
1788 DisplayPoint::new(0, 0)
1789 );
1790 assert_eq!(
1791 map.clip_point(DisplayPoint::new(0, "ā
".len() as u32 - 1), Bias::Right),
1792 DisplayPoint::new(0, "ā
".len() as u32)
1793 );
1794 }
1795
1796 #[gpui::test]
1797 fn test_max_point(cx: &mut gpui::AppContext) {
1798 init_test(cx, |_| {});
1799
1800 let buffer = MultiBuffer::build_simple("aaa\n\t\tbbb", cx);
1801 let font_size = px(14.0);
1802 let map = cx.build_model(|cx| {
1803 DisplayMap::new(buffer.clone(), font("Helvetica"), font_size, None, 1, 1, cx)
1804 });
1805 assert_eq!(
1806 map.update(cx, |map, cx| map.snapshot(cx)).max_point(),
1807 DisplayPoint::new(1, 11)
1808 )
1809 }
1810
1811 fn syntax_chunks<'a>(
1812 rows: Range<u32>,
1813 map: &Model<DisplayMap>,
1814 theme: &'a SyntaxTheme,
1815 cx: &mut AppContext,
1816 ) -> Vec<(String, Option<Hsla>)> {
1817 chunks(rows, map, theme, cx)
1818 .into_iter()
1819 .map(|(text, color, _)| (text, color))
1820 .collect()
1821 }
1822
1823 fn chunks<'a>(
1824 rows: Range<u32>,
1825 map: &Model<DisplayMap>,
1826 theme: &'a SyntaxTheme,
1827 cx: &mut AppContext,
1828 ) -> Vec<(String, Option<Hsla>, Option<Hsla>)> {
1829 let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
1830 let mut chunks: Vec<(String, Option<Hsla>, Option<Hsla>)> = Vec::new();
1831 for chunk in snapshot.chunks(rows, true, None, None) {
1832 let syntax_color = chunk
1833 .syntax_highlight_id
1834 .and_then(|id| id.style(theme)?.color);
1835 let highlight_color = chunk.highlight_style.and_then(|style| style.color);
1836 if let Some((last_chunk, last_syntax_color, last_highlight_color)) = chunks.last_mut() {
1837 if syntax_color == *last_syntax_color && highlight_color == *last_highlight_color {
1838 last_chunk.push_str(chunk.text);
1839 continue;
1840 }
1841 }
1842 chunks.push((chunk.text.to_string(), syntax_color, highlight_color));
1843 }
1844 chunks
1845 }
1846
1847 fn init_test(cx: &mut AppContext, f: impl Fn(&mut AllLanguageSettingsContent)) {
1848 let settings = SettingsStore::test(cx);
1849 cx.set_global(settings);
1850 language::init(cx);
1851 crate::init(cx);
1852 Project::init_settings(cx);
1853 theme::init(LoadThemes::JustBase, cx);
1854 cx.update_global::<SettingsStore, _>(|store, cx| {
1855 store.update_user_settings::<AllLanguageSettings>(cx, f);
1856 });
1857 }
1858}