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