1use editor::{Cursor, HighlightedRange, HighlightedRangeLine};
2use gpui::{
3 color::Color,
4 elements::{Empty, Overlay},
5 fonts::{HighlightStyle, Properties, Style::Italic, TextStyle, Underline, Weight},
6 geometry::{
7 rect::RectF,
8 vector::{vec2f, Vector2F},
9 },
10 platform::{CursorStyle, MouseButton},
11 serde_json::json,
12 text_layout::{Line, RunStyle},
13 AnyElement, Element, EventContext, FontCache, ModelContext, MouseRegion, Quad, SceneBuilder,
14 SizeConstraint, TextLayoutCache, ViewContext, WeakModelHandle,
15};
16use itertools::Itertools;
17use language::CursorShape;
18use ordered_float::OrderedFloat;
19use settings::Settings;
20use terminal::{
21 alacritty_terminal::{
22 ansi::{Color as AnsiColor, Color::Named, CursorShape as AlacCursorShape, NamedColor},
23 grid::Dimensions,
24 index::Point,
25 term::{cell::Flags, TermMode},
26 },
27 mappings::colors::convert_color,
28 IndexedCell, Terminal, TerminalContent, TerminalSize,
29};
30use theme::TerminalStyle;
31use util::ResultExt;
32
33use std::{fmt::Debug, ops::RangeInclusive};
34use std::{mem, ops::Range};
35
36use crate::{DeployContextMenu, TerminalView};
37
38///The information generated during layout that is nescessary for painting
39pub struct LayoutState {
40 cells: Vec<LayoutCell>,
41 rects: Vec<LayoutRect>,
42 relative_highlighted_ranges: Vec<(RangeInclusive<Point>, Color)>,
43 cursor: Option<Cursor>,
44 background_color: Color,
45 size: TerminalSize,
46 mode: TermMode,
47 display_offset: usize,
48 hyperlink_tooltip: Option<AnyElement<TerminalView>>,
49}
50
51///Helper struct for converting data between alacritty's cursor points, and displayed cursor points
52struct DisplayCursor {
53 line: i32,
54 col: usize,
55}
56
57impl DisplayCursor {
58 fn from(cursor_point: Point, display_offset: usize) -> Self {
59 Self {
60 line: cursor_point.line.0 + display_offset as i32,
61 col: cursor_point.column.0,
62 }
63 }
64
65 pub fn line(&self) -> i32 {
66 self.line
67 }
68
69 pub fn col(&self) -> usize {
70 self.col
71 }
72}
73
74#[derive(Clone, Debug, Default)]
75struct LayoutCell {
76 point: Point<i32, i32>,
77 text: Line,
78}
79
80impl LayoutCell {
81 fn new(point: Point<i32, i32>, text: Line) -> LayoutCell {
82 LayoutCell { point, text }
83 }
84
85 fn paint(
86 &self,
87 scene: &mut SceneBuilder,
88 origin: Vector2F,
89 layout: &LayoutState,
90 visible_bounds: RectF,
91 _view: &mut TerminalView,
92 cx: &mut ViewContext<TerminalView>,
93 ) {
94 let pos = {
95 let point = self.point;
96 vec2f(
97 (origin.x() + point.column as f32 * layout.size.cell_width).floor(),
98 origin.y() + point.line as f32 * layout.size.line_height,
99 )
100 };
101
102 self.text
103 .paint(scene, pos, visible_bounds, layout.size.line_height, cx);
104 }
105}
106
107#[derive(Clone, Debug, Default)]
108struct LayoutRect {
109 point: Point<i32, i32>,
110 num_of_cells: usize,
111 color: Color,
112}
113
114impl LayoutRect {
115 fn new(point: Point<i32, i32>, num_of_cells: usize, color: Color) -> LayoutRect {
116 LayoutRect {
117 point,
118 num_of_cells,
119 color,
120 }
121 }
122
123 fn extend(&self) -> Self {
124 LayoutRect {
125 point: self.point,
126 num_of_cells: self.num_of_cells + 1,
127 color: self.color,
128 }
129 }
130
131 fn paint(
132 &self,
133 scene: &mut SceneBuilder,
134 origin: Vector2F,
135 layout: &LayoutState,
136 _view: &mut TerminalView,
137 _cx: &mut ViewContext<TerminalView>,
138 ) {
139 let position = {
140 let point = self.point;
141 vec2f(
142 (origin.x() + point.column as f32 * layout.size.cell_width).floor(),
143 origin.y() + point.line as f32 * layout.size.line_height,
144 )
145 };
146 let size = vec2f(
147 (layout.size.cell_width * self.num_of_cells as f32).ceil(),
148 layout.size.line_height,
149 );
150
151 scene.push_quad(Quad {
152 bounds: RectF::new(position, size),
153 background: Some(self.color),
154 border: Default::default(),
155 corner_radius: 0.,
156 })
157 }
158}
159
160///The GPUI element that paints the terminal.
161///We need to keep a reference to the view for mouse events, do we need it for any other terminal stuff, or can we move that to connection?
162pub struct TerminalElement {
163 terminal: WeakModelHandle<Terminal>,
164 focused: bool,
165 cursor_visible: bool,
166}
167
168impl TerminalElement {
169 pub fn new(
170 terminal: WeakModelHandle<Terminal>,
171 focused: bool,
172 cursor_visible: bool,
173 ) -> TerminalElement {
174 TerminalElement {
175 terminal,
176 focused,
177 cursor_visible,
178 }
179 }
180
181 //Vec<Range<Point>> -> Clip out the parts of the ranges
182
183 fn layout_grid(
184 grid: &Vec<IndexedCell>,
185 text_style: &TextStyle,
186 terminal_theme: &TerminalStyle,
187 text_layout_cache: &TextLayoutCache,
188 font_cache: &FontCache,
189 hyperlink: Option<(HighlightStyle, &RangeInclusive<Point>)>,
190 ) -> (Vec<LayoutCell>, Vec<LayoutRect>) {
191 let mut cells = vec![];
192 let mut rects = vec![];
193
194 let mut cur_rect: Option<LayoutRect> = None;
195 let mut cur_alac_color = None;
196
197 let linegroups = grid.into_iter().group_by(|i| i.point.line);
198 for (line_index, (_, line)) in linegroups.into_iter().enumerate() {
199 for cell in line {
200 let mut fg = cell.fg;
201 let mut bg = cell.bg;
202 if cell.flags.contains(Flags::INVERSE) {
203 mem::swap(&mut fg, &mut bg);
204 }
205
206 //Expand background rect range
207 {
208 if matches!(bg, Named(NamedColor::Background)) {
209 //Continue to next cell, resetting variables if nescessary
210 cur_alac_color = None;
211 if let Some(rect) = cur_rect {
212 rects.push(rect);
213 cur_rect = None
214 }
215 } else {
216 match cur_alac_color {
217 Some(cur_color) => {
218 if bg == cur_color {
219 cur_rect = cur_rect.take().map(|rect| rect.extend());
220 } else {
221 cur_alac_color = Some(bg);
222 if cur_rect.is_some() {
223 rects.push(cur_rect.take().unwrap());
224 }
225 cur_rect = Some(LayoutRect::new(
226 Point::new(line_index as i32, cell.point.column.0 as i32),
227 1,
228 convert_color(&bg, &terminal_theme),
229 ));
230 }
231 }
232 None => {
233 cur_alac_color = Some(bg);
234 cur_rect = Some(LayoutRect::new(
235 Point::new(line_index as i32, cell.point.column.0 as i32),
236 1,
237 convert_color(&bg, &terminal_theme),
238 ));
239 }
240 }
241 }
242 }
243
244 //Layout current cell text
245 {
246 let cell_text = &cell.c.to_string();
247 if !is_blank(&cell) {
248 let cell_style = TerminalElement::cell_style(
249 &cell,
250 fg,
251 terminal_theme,
252 text_style,
253 font_cache,
254 hyperlink,
255 );
256
257 let layout_cell = text_layout_cache.layout_str(
258 cell_text,
259 text_style.font_size,
260 &[(cell_text.len(), cell_style)],
261 );
262
263 cells.push(LayoutCell::new(
264 Point::new(line_index as i32, cell.point.column.0 as i32),
265 layout_cell,
266 ))
267 };
268 }
269 }
270
271 if cur_rect.is_some() {
272 rects.push(cur_rect.take().unwrap());
273 }
274 }
275 (cells, rects)
276 }
277
278 // Compute the cursor position and expected block width, may return a zero width if x_for_index returns
279 // the same position for sequential indexes. Use em_width instead
280 fn shape_cursor(
281 cursor_point: DisplayCursor,
282 size: TerminalSize,
283 text_fragment: &Line,
284 ) -> Option<(Vector2F, f32)> {
285 if cursor_point.line() < size.total_lines() as i32 {
286 let cursor_width = if text_fragment.width() == 0. {
287 size.cell_width()
288 } else {
289 text_fragment.width()
290 };
291
292 //Cursor should always surround as much of the text as possible,
293 //hence when on pixel boundaries round the origin down and the width up
294 Some((
295 vec2f(
296 (cursor_point.col() as f32 * size.cell_width()).floor(),
297 (cursor_point.line() as f32 * size.line_height()).floor(),
298 ),
299 cursor_width.ceil(),
300 ))
301 } else {
302 None
303 }
304 }
305
306 ///Convert the Alacritty cell styles to GPUI text styles and background color
307 fn cell_style(
308 indexed: &IndexedCell,
309 fg: terminal::alacritty_terminal::ansi::Color,
310 style: &TerminalStyle,
311 text_style: &TextStyle,
312 font_cache: &FontCache,
313 hyperlink: Option<(HighlightStyle, &RangeInclusive<Point>)>,
314 ) -> RunStyle {
315 let flags = indexed.cell.flags;
316 let fg = convert_color(&fg, &style);
317
318 let mut underline = flags
319 .intersects(Flags::ALL_UNDERLINES)
320 .then(|| Underline {
321 color: Some(fg),
322 squiggly: flags.contains(Flags::UNDERCURL),
323 thickness: OrderedFloat(1.),
324 })
325 .unwrap_or_default();
326
327 if indexed.cell.hyperlink().is_some() {
328 if underline.thickness == OrderedFloat(0.) {
329 underline.thickness = OrderedFloat(1.);
330 }
331 }
332
333 let mut properties = Properties::new();
334 if indexed.flags.intersects(Flags::BOLD | Flags::DIM_BOLD) {
335 properties = *properties.weight(Weight::BOLD);
336 }
337 if indexed.flags.intersects(Flags::ITALIC) {
338 properties = *properties.style(Italic);
339 }
340
341 let font_id = font_cache
342 .select_font(text_style.font_family_id, &properties)
343 .unwrap_or(text_style.font_id);
344
345 let mut result = RunStyle {
346 color: fg,
347 font_id,
348 underline,
349 };
350
351 if let Some((style, range)) = hyperlink {
352 if range.contains(&indexed.point) {
353 if let Some(underline) = style.underline {
354 result.underline = underline;
355 }
356
357 if let Some(color) = style.color {
358 result.color = color;
359 }
360 }
361 }
362
363 result
364 }
365
366 fn generic_button_handler<E>(
367 connection: WeakModelHandle<Terminal>,
368 origin: Vector2F,
369 f: impl Fn(&mut Terminal, Vector2F, E, &mut ModelContext<Terminal>),
370 ) -> impl Fn(E, &mut TerminalView, &mut EventContext<TerminalView>) {
371 move |event, _: &mut TerminalView, cx| {
372 cx.focus_parent_view();
373 if let Some(conn_handle) = connection.upgrade(cx) {
374 conn_handle.update(cx, |terminal, cx| {
375 f(terminal, origin, event, cx);
376
377 cx.notify();
378 })
379 }
380 }
381 }
382
383 fn attach_mouse_handlers(
384 &self,
385 scene: &mut SceneBuilder,
386 origin: Vector2F,
387 visible_bounds: RectF,
388 mode: TermMode,
389 cx: &mut ViewContext<TerminalView>,
390 ) {
391 let connection = self.terminal;
392
393 let mut region = MouseRegion::new::<Self>(cx.view_id(), 0, visible_bounds);
394
395 // Terminal Emulator controlled behavior:
396 region = region
397 // Start selections
398 .on_down(
399 MouseButton::Left,
400 TerminalElement::generic_button_handler(
401 connection,
402 origin,
403 move |terminal, origin, e, _cx| {
404 terminal.mouse_down(&e, origin);
405 },
406 ),
407 )
408 // Update drag selections
409 .on_drag(MouseButton::Left, move |event, _: &mut TerminalView, cx| {
410 if cx.is_parent_view_focused() {
411 if let Some(conn_handle) = connection.upgrade(cx) {
412 conn_handle.update(cx, |terminal, cx| {
413 terminal.mouse_drag(event, origin);
414 cx.notify();
415 })
416 }
417 }
418 })
419 // Copy on up behavior
420 .on_up(
421 MouseButton::Left,
422 TerminalElement::generic_button_handler(
423 connection,
424 origin,
425 move |terminal, origin, e, cx| {
426 terminal.mouse_up(&e, origin, cx);
427 },
428 ),
429 )
430 // Context menu
431 .on_click(MouseButton::Right, move |e, _: &mut TerminalView, cx| {
432 let mouse_mode = if let Some(conn_handle) = connection.upgrade(cx) {
433 conn_handle.update(cx, |terminal, _cx| terminal.mouse_mode(e.shift))
434 } else {
435 // If we can't get the model handle, probably can't deploy the context menu
436 true
437 };
438 if !mouse_mode {
439 cx.dispatch_action(DeployContextMenu {
440 position: e.position,
441 });
442 }
443 })
444 .on_move(move |event, _: &mut TerminalView, cx| {
445 if cx.is_parent_view_focused() {
446 if let Some(conn_handle) = connection.upgrade(cx) {
447 conn_handle.update(cx, |terminal, cx| {
448 terminal.mouse_move(&event, origin);
449 cx.notify();
450 })
451 }
452 }
453 })
454 .on_scroll(move |event, _: &mut TerminalView, cx| {
455 if let Some(conn_handle) = connection.upgrade(cx) {
456 conn_handle.update(cx, |terminal, cx| {
457 terminal.scroll_wheel(event, origin);
458 cx.notify();
459 })
460 }
461 });
462
463 // Mouse mode handlers:
464 // All mouse modes need the extra click handlers
465 if mode.intersects(TermMode::MOUSE_MODE) {
466 region = region
467 .on_down(
468 MouseButton::Right,
469 TerminalElement::generic_button_handler(
470 connection,
471 origin,
472 move |terminal, origin, e, _cx| {
473 terminal.mouse_down(&e, origin);
474 },
475 ),
476 )
477 .on_down(
478 MouseButton::Middle,
479 TerminalElement::generic_button_handler(
480 connection,
481 origin,
482 move |terminal, origin, e, _cx| {
483 terminal.mouse_down(&e, origin);
484 },
485 ),
486 )
487 .on_up(
488 MouseButton::Right,
489 TerminalElement::generic_button_handler(
490 connection,
491 origin,
492 move |terminal, origin, e, cx| {
493 terminal.mouse_up(&e, origin, cx);
494 },
495 ),
496 )
497 .on_up(
498 MouseButton::Middle,
499 TerminalElement::generic_button_handler(
500 connection,
501 origin,
502 move |terminal, origin, e, cx| {
503 terminal.mouse_up(&e, origin, cx);
504 },
505 ),
506 )
507 }
508
509 scene.push_mouse_region(region);
510 }
511
512 ///Configures a text style from the current settings.
513 pub fn make_text_style(font_cache: &FontCache, settings: &Settings) -> TextStyle {
514 let font_family_name = settings
515 .terminal_overrides
516 .font_family
517 .as_ref()
518 .or(settings.terminal_defaults.font_family.as_ref())
519 .unwrap_or(&settings.buffer_font_family_name);
520 let font_features = settings
521 .terminal_overrides
522 .font_features
523 .as_ref()
524 .or(settings.terminal_defaults.font_features.as_ref())
525 .unwrap_or(&settings.buffer_font_features);
526
527 let family_id = font_cache
528 .load_family(&[font_family_name], &font_features)
529 .log_err()
530 .unwrap_or(settings.buffer_font_family);
531
532 let font_size = settings
533 .terminal_overrides
534 .font_size
535 .or(settings.terminal_defaults.font_size)
536 .unwrap_or(settings.buffer_font_size);
537
538 let font_id = font_cache
539 .select_font(family_id, &Default::default())
540 .unwrap();
541
542 TextStyle {
543 color: settings.theme.editor.text_color,
544 font_family_id: family_id,
545 font_family_name: font_cache.family_name(family_id).unwrap(),
546 font_id,
547 font_size,
548 font_properties: Default::default(),
549 underline: Default::default(),
550 }
551 }
552}
553
554impl Element<TerminalView> for TerminalElement {
555 type LayoutState = LayoutState;
556 type PaintState = ();
557
558 fn layout(
559 &mut self,
560 constraint: gpui::SizeConstraint,
561 view: &mut TerminalView,
562 cx: &mut ViewContext<TerminalView>,
563 ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
564 let settings = cx.global::<Settings>();
565 let font_cache = cx.font_cache();
566
567 //Setup layout information
568 let terminal_theme = settings.theme.terminal.clone(); //TODO: Try to minimize this clone.
569 let link_style = settings.theme.editor.link_definition;
570 let tooltip_style = settings.theme.tooltip.clone();
571
572 let text_style = TerminalElement::make_text_style(font_cache, settings);
573 let selection_color = settings.theme.editor.selection.selection;
574 let match_color = settings.theme.search.match_background;
575 let dimensions = {
576 let line_height = text_style.font_size * settings.terminal_line_height();
577 let cell_width = font_cache.em_advance(text_style.font_id, text_style.font_size);
578 TerminalSize::new(line_height, cell_width, constraint.max)
579 };
580
581 let search_matches = if let Some(terminal_model) = self.terminal.upgrade(cx) {
582 terminal_model.read(cx).matches.clone()
583 } else {
584 Default::default()
585 };
586
587 let background_color = terminal_theme.background;
588 let terminal_handle = self.terminal.upgrade(cx).unwrap();
589
590 let last_hovered_hyperlink = terminal_handle.update(cx, |terminal, cx| {
591 terminal.set_size(dimensions);
592 terminal.try_sync(cx);
593 terminal.last_content.last_hovered_hyperlink.clone()
594 });
595
596 let hyperlink_tooltip = last_hovered_hyperlink.map(|(uri, _, id)| {
597 let mut tooltip = Overlay::new(
598 Empty::new()
599 .contained()
600 .constrained()
601 .with_width(dimensions.width())
602 .with_height(dimensions.height())
603 .with_tooltip::<TerminalElement>(id, uri, None, tooltip_style, cx),
604 )
605 .with_position_mode(gpui::elements::OverlayPositionMode::Local)
606 .into_any();
607
608 tooltip.layout(
609 SizeConstraint::new(Vector2F::zero(), cx.window_size()),
610 view,
611 cx,
612 );
613 tooltip
614 });
615
616 let TerminalContent {
617 cells,
618 mode,
619 display_offset,
620 cursor_char,
621 selection,
622 cursor,
623 last_hovered_hyperlink,
624 ..
625 } = { &terminal_handle.read(cx).last_content };
626
627 // searches, highlights to a single range representations
628 let mut relative_highlighted_ranges = Vec::new();
629 for search_match in search_matches {
630 relative_highlighted_ranges.push((search_match, match_color))
631 }
632 if let Some(selection) = selection {
633 relative_highlighted_ranges.push((selection.start..=selection.end, selection_color));
634 }
635
636 // then have that representation be converted to the appropriate highlight data structure
637
638 let (cells, rects) = TerminalElement::layout_grid(
639 cells,
640 &text_style,
641 &terminal_theme,
642 cx.text_layout_cache(),
643 cx.font_cache(),
644 last_hovered_hyperlink
645 .as_ref()
646 .map(|(_, range, _)| (link_style, range)),
647 );
648
649 //Layout cursor. Rectangle is used for IME, so we should lay it out even
650 //if we don't end up showing it.
651 let cursor = if let AlacCursorShape::Hidden = cursor.shape {
652 None
653 } else {
654 let cursor_point = DisplayCursor::from(cursor.point, *display_offset);
655 let cursor_text = {
656 let str_trxt = cursor_char.to_string();
657
658 let color = if self.focused {
659 terminal_theme.background
660 } else {
661 terminal_theme.foreground
662 };
663
664 cx.text_layout_cache().layout_str(
665 &str_trxt,
666 text_style.font_size,
667 &[(
668 str_trxt.len(),
669 RunStyle {
670 font_id: text_style.font_id,
671 color,
672 underline: Default::default(),
673 },
674 )],
675 )
676 };
677
678 let focused = self.focused;
679 TerminalElement::shape_cursor(cursor_point, dimensions, &cursor_text).map(
680 move |(cursor_position, block_width)| {
681 let (shape, text) = match cursor.shape {
682 AlacCursorShape::Block if !focused => (CursorShape::Hollow, None),
683 AlacCursorShape::Block => (CursorShape::Block, Some(cursor_text)),
684 AlacCursorShape::Underline => (CursorShape::Underscore, None),
685 AlacCursorShape::Beam => (CursorShape::Bar, None),
686 AlacCursorShape::HollowBlock => (CursorShape::Hollow, None),
687 //This case is handled in the if wrapping the whole cursor layout
688 AlacCursorShape::Hidden => unreachable!(),
689 };
690
691 Cursor::new(
692 cursor_position,
693 block_width,
694 dimensions.line_height,
695 terminal_theme.cursor,
696 shape,
697 text,
698 )
699 },
700 )
701 };
702
703 //Done!
704 (
705 constraint.max,
706 LayoutState {
707 cells,
708 cursor,
709 background_color,
710 size: dimensions,
711 rects,
712 relative_highlighted_ranges,
713 mode: *mode,
714 display_offset: *display_offset,
715 hyperlink_tooltip,
716 },
717 )
718 }
719
720 fn paint(
721 &mut self,
722 scene: &mut SceneBuilder,
723 bounds: RectF,
724 visible_bounds: RectF,
725 layout: &mut Self::LayoutState,
726 view: &mut TerminalView,
727 cx: &mut ViewContext<TerminalView>,
728 ) -> Self::PaintState {
729 let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();
730
731 //Setup element stuff
732 let clip_bounds = Some(visible_bounds);
733
734 scene.paint_layer(clip_bounds, |scene| {
735 let origin = bounds.origin() + vec2f(layout.size.cell_width, 0.);
736
737 // Elements are ephemeral, only at paint time do we know what could be clicked by a mouse
738 self.attach_mouse_handlers(scene, origin, visible_bounds, layout.mode, cx);
739
740 scene.push_cursor_region(gpui::CursorRegion {
741 bounds,
742 style: if layout.hyperlink_tooltip.is_some() {
743 CursorStyle::PointingHand
744 } else {
745 CursorStyle::IBeam
746 },
747 });
748
749 scene.paint_layer(clip_bounds, |scene| {
750 //Start with a background color
751 scene.push_quad(Quad {
752 bounds: RectF::new(bounds.origin(), bounds.size()),
753 background: Some(layout.background_color),
754 border: Default::default(),
755 corner_radius: 0.,
756 });
757
758 for rect in &layout.rects {
759 rect.paint(scene, origin, layout, view, cx)
760 }
761 });
762
763 //Draw Highlighted Backgrounds
764 scene.paint_layer(clip_bounds, |scene| {
765 for (relative_highlighted_range, color) in layout.relative_highlighted_ranges.iter()
766 {
767 if let Some((start_y, highlighted_range_lines)) =
768 to_highlighted_range_lines(relative_highlighted_range, layout, origin)
769 {
770 let hr = HighlightedRange {
771 start_y, //Need to change this
772 line_height: layout.size.line_height,
773 lines: highlighted_range_lines,
774 color: color.clone(),
775 //Copied from editor. TODO: move to theme or something
776 corner_radius: 0.15 * layout.size.line_height,
777 };
778 hr.paint(bounds, scene);
779 }
780 }
781 });
782
783 //Draw the text cells
784 scene.paint_layer(clip_bounds, |scene| {
785 for cell in &layout.cells {
786 cell.paint(scene, origin, layout, visible_bounds, view, cx);
787 }
788 });
789
790 //Draw cursor
791 if self.cursor_visible {
792 if let Some(cursor) = &layout.cursor {
793 scene.paint_layer(clip_bounds, |scene| {
794 cursor.paint(scene, origin, cx);
795 })
796 }
797 }
798
799 if let Some(element) = &mut layout.hyperlink_tooltip {
800 element.paint(scene, origin, visible_bounds, view, cx)
801 }
802 });
803 }
804
805 fn metadata(&self) -> Option<&dyn std::any::Any> {
806 None
807 }
808
809 fn debug(
810 &self,
811 _: RectF,
812 _: &Self::LayoutState,
813 _: &Self::PaintState,
814 _: &TerminalView,
815 _: &gpui::ViewContext<TerminalView>,
816 ) -> gpui::serde_json::Value {
817 json!({
818 "type": "TerminalElement",
819 })
820 }
821
822 fn rect_for_text_range(
823 &self,
824 _: Range<usize>,
825 bounds: RectF,
826 _: RectF,
827 layout: &Self::LayoutState,
828 _: &Self::PaintState,
829 _: &TerminalView,
830 _: &gpui::ViewContext<TerminalView>,
831 ) -> Option<RectF> {
832 // Use the same origin that's passed to `Cursor::paint` in the paint
833 // method bove.
834 let mut origin = bounds.origin() + vec2f(layout.size.cell_width, 0.);
835
836 // TODO - Why is it necessary to move downward one line to get correct
837 // positioning? I would think that we'd want the same rect that is
838 // painted for the cursor.
839 origin += vec2f(0., layout.size.line_height);
840
841 Some(layout.cursor.as_ref()?.bounding_rect(origin))
842 }
843}
844
845fn is_blank(cell: &IndexedCell) -> bool {
846 if cell.c != ' ' {
847 return false;
848 }
849
850 if cell.bg != AnsiColor::Named(NamedColor::Background) {
851 return false;
852 }
853
854 if cell.hyperlink().is_some() {
855 return false;
856 }
857
858 if cell
859 .flags
860 .intersects(Flags::ALL_UNDERLINES | Flags::INVERSE | Flags::STRIKEOUT)
861 {
862 return false;
863 }
864
865 return true;
866}
867
868fn to_highlighted_range_lines(
869 range: &RangeInclusive<Point>,
870 layout: &LayoutState,
871 origin: Vector2F,
872) -> Option<(f32, Vec<HighlightedRangeLine>)> {
873 // Step 1. Normalize the points to be viewport relative.
874 // When display_offset = 1, here's how the grid is arranged:
875 //-2,0 -2,1...
876 //--- Viewport top
877 //-1,0 -1,1...
878 //--------- Terminal Top
879 // 0,0 0,1...
880 // 1,0 1,1...
881 //--- Viewport Bottom
882 // 2,0 2,1...
883 //--------- Terminal Bottom
884
885 // Normalize to viewport relative, from terminal relative.
886 // lines are i32s, which are negative above the top left corner of the terminal
887 // If the user has scrolled, we use the display_offset to tell us which offset
888 // of the grid data we should be looking at. But for the rendering step, we don't
889 // want negatives. We want things relative to the 'viewport' (the area of the grid
890 // which is currently shown according to the display offset)
891 let unclamped_start = Point::new(
892 range.start().line + layout.display_offset,
893 range.start().column,
894 );
895 let unclamped_end = Point::new(range.end().line + layout.display_offset, range.end().column);
896
897 // Step 2. Clamp range to viewport, and return None if it doesn't overlap
898 if unclamped_end.line.0 < 0 || unclamped_start.line.0 > layout.size.num_lines() as i32 {
899 return None;
900 }
901
902 let clamped_start_line = unclamped_start.line.0.max(0) as usize;
903 let clamped_end_line = unclamped_end.line.0.min(layout.size.num_lines() as i32) as usize;
904 //Convert the start of the range to pixels
905 let start_y = origin.y() + clamped_start_line as f32 * layout.size.line_height;
906
907 // Step 3. Expand ranges that cross lines into a collection of single-line ranges.
908 // (also convert to pixels)
909 let mut highlighted_range_lines = Vec::new();
910 for line in clamped_start_line..=clamped_end_line {
911 let mut line_start = 0;
912 let mut line_end = layout.size.columns();
913
914 if line == clamped_start_line {
915 line_start = unclamped_start.column.0 as usize;
916 }
917 if line == clamped_end_line {
918 line_end = unclamped_end.column.0 as usize + 1; //+1 for inclusive
919 }
920
921 highlighted_range_lines.push(HighlightedRangeLine {
922 start_x: origin.x() + line_start as f32 * layout.size.cell_width,
923 end_x: origin.x() + line_end as f32 * layout.size.cell_width,
924 });
925 }
926
927 Some((start_y, highlighted_range_lines))
928}