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(move |event, cx| {
457 // cx.focus_parent_view();
458 if let Some(conn_handle) = connection.upgrade(cx.app) {
459 conn_handle.update(cx.app, |terminal, cx| {
460 terminal.scroll_wheel(event, origin);
461 cx.notify();
462 })
463 }
464 });
465
466 // Mouse mode handlers:
467 // All mouse modes need the extra click handlers
468 if mode.intersects(TermMode::MOUSE_MODE) {
469 region = region
470 .on_down(
471 MouseButton::Right,
472 TerminalElement::generic_button_handler(
473 connection,
474 origin,
475 move |terminal, origin, e, _cx| {
476 terminal.mouse_down(&e, origin);
477 },
478 ),
479 )
480 .on_down(
481 MouseButton::Middle,
482 TerminalElement::generic_button_handler(
483 connection,
484 origin,
485 move |terminal, origin, e, _cx| {
486 terminal.mouse_down(&e, origin);
487 },
488 ),
489 )
490 .on_up(
491 MouseButton::Right,
492 TerminalElement::generic_button_handler(
493 connection,
494 origin,
495 move |terminal, origin, e, _cx| {
496 terminal.mouse_up(&e, origin);
497 },
498 ),
499 )
500 .on_up(
501 MouseButton::Middle,
502 TerminalElement::generic_button_handler(
503 connection,
504 origin,
505 move |terminal, origin, e, _cx| {
506 terminal.mouse_up(&e, origin);
507 },
508 ),
509 )
510 }
511
512 cx.scene.push_mouse_region(region);
513 }
514
515 ///Configures a text style from the current settings.
516 pub fn make_text_style(font_cache: &FontCache, settings: &Settings) -> TextStyle {
517 // Pull the font family from settings properly overriding
518 let family_id = settings
519 .terminal_overrides
520 .font_family
521 .as_ref()
522 .or(settings.terminal_defaults.font_family.as_ref())
523 .and_then(|family_name| font_cache.load_family(&[family_name]).log_err())
524 .unwrap_or(settings.buffer_font_family);
525
526 let font_size = settings
527 .terminal_overrides
528 .font_size
529 .or(settings.terminal_defaults.font_size)
530 .unwrap_or(settings.buffer_font_size);
531
532 let font_id = font_cache
533 .select_font(family_id, &Default::default())
534 .unwrap();
535
536 TextStyle {
537 color: settings.theme.editor.text_color,
538 font_family_id: family_id,
539 font_family_name: font_cache.family_name(family_id).unwrap(),
540 font_id,
541 font_size,
542 font_properties: Default::default(),
543 underline: Default::default(),
544 }
545 }
546}
547
548impl Element for TerminalElement {
549 type LayoutState = LayoutState;
550 type PaintState = ();
551
552 fn layout(
553 &mut self,
554 constraint: gpui::SizeConstraint,
555 cx: &mut gpui::LayoutContext,
556 ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
557 let settings = cx.global::<Settings>();
558 let font_cache = cx.font_cache();
559
560 //Setup layout information
561 let terminal_theme = settings.theme.terminal.clone(); //TODO: Try to minimize this clone.
562 let link_style = settings.theme.editor.link_definition;
563 let tooltip_style = settings.theme.tooltip.clone();
564
565 let text_style = TerminalElement::make_text_style(font_cache, settings);
566 let selection_color = settings.theme.editor.selection.selection;
567 let match_color = settings.theme.search.match_background;
568 let dimensions = {
569 let line_height = font_cache.line_height(text_style.font_size);
570 let cell_width = font_cache.em_advance(text_style.font_id, text_style.font_size);
571 TerminalSize::new(line_height, cell_width, constraint.max)
572 };
573
574 let search_matches = if let Some(terminal_model) = self.terminal.upgrade(cx) {
575 terminal_model.read(cx).matches.clone()
576 } else {
577 Default::default()
578 };
579
580 let background_color = if self.modal {
581 terminal_theme.colors.modal_background
582 } else {
583 terminal_theme.colors.background
584 };
585 let terminal_handle = self.terminal.upgrade(cx).unwrap();
586
587 let last_hovered_hyperlink = terminal_handle.update(cx.app, |terminal, cx| {
588 terminal.set_size(dimensions);
589 terminal.try_sync(cx);
590 terminal.last_content.last_hovered_hyperlink.clone()
591 });
592
593 let view_handle = self.view.clone();
594 let hyperlink_tooltip = last_hovered_hyperlink.and_then(|(uri, _, id)| {
595 // last_mouse.and_then(|_last_mouse| {
596 view_handle.upgrade(cx).map(|handle| {
597 let mut tooltip = cx.render(&handle, |_, cx| {
598 Overlay::new(
599 Empty::new()
600 .contained()
601 .constrained()
602 .with_width(dimensions.width())
603 .with_height(dimensions.height())
604 .with_tooltip::<TerminalElement, _>(id, uri, None, tooltip_style, cx)
605 .boxed(),
606 )
607 .with_position_mode(gpui::elements::OverlayPositionMode::Local)
608 .boxed()
609 });
610
611 tooltip.layout(SizeConstraint::new(Vector2F::zero(), cx.window_size), cx);
612 tooltip
613 })
614 // })
615 });
616
617 let TerminalContent {
618 cells,
619 mode,
620 display_offset,
621 cursor_char,
622 selection,
623 cursor,
624 last_hovered_hyperlink,
625 ..
626 } = { &terminal_handle.read(cx).last_content };
627
628 // searches, highlights to a single range representations
629 let mut relative_highlighted_ranges = Vec::new();
630 for search_match in search_matches {
631 relative_highlighted_ranges.push((search_match, match_color))
632 }
633 if let Some(selection) = selection {
634 relative_highlighted_ranges.push((selection.start..=selection.end, selection_color));
635 }
636
637 // then have that representation be converted to the appropriate highlight data structure
638
639 let (cells, rects) = TerminalElement::layout_grid(
640 cells,
641 &text_style,
642 &terminal_theme,
643 cx.text_layout_cache,
644 cx.font_cache(),
645 self.modal,
646 last_hovered_hyperlink
647 .as_ref()
648 .map(|(_, range, _)| (link_style, range)),
649 );
650
651 //Layout cursor. Rectangle is used for IME, so we should lay it out even
652 //if we don't end up showing it.
653 let cursor = if let AlacCursorShape::Hidden = cursor.shape {
654 None
655 } else {
656 let cursor_point = DisplayCursor::from(cursor.point, *display_offset);
657 let cursor_text = {
658 let str_trxt = cursor_char.to_string();
659
660 let color = if self.focused {
661 terminal_theme.colors.background
662 } else {
663 terminal_theme.colors.foreground
664 };
665
666 cx.text_layout_cache.layout_str(
667 &str_trxt,
668 text_style.font_size,
669 &[(
670 str_trxt.len(),
671 RunStyle {
672 font_id: text_style.font_id,
673 color,
674 underline: Default::default(),
675 },
676 )],
677 )
678 };
679
680 let focused = self.focused;
681 TerminalElement::shape_cursor(cursor_point, dimensions, &cursor_text).map(
682 move |(cursor_position, block_width)| {
683 let shape = match cursor.shape {
684 AlacCursorShape::Block if !focused => CursorShape::Hollow,
685 AlacCursorShape::Block => CursorShape::Block,
686 AlacCursorShape::Underline => CursorShape::Underscore,
687 AlacCursorShape::Beam => CursorShape::Bar,
688 AlacCursorShape::HollowBlock => CursorShape::Hollow,
689 //This case is handled in the if wrapping the whole cursor layout
690 AlacCursorShape::Hidden => unreachable!(),
691 };
692
693 Cursor::new(
694 cursor_position,
695 block_width,
696 dimensions.line_height,
697 terminal_theme.colors.cursor,
698 shape,
699 Some(cursor_text),
700 )
701 },
702 )
703 };
704
705 //Done!
706 (
707 constraint.max,
708 LayoutState {
709 cells,
710 cursor,
711 background_color,
712 size: dimensions,
713 rects,
714 relative_highlighted_ranges,
715 mode: *mode,
716 display_offset: *display_offset,
717 hyperlink_tooltip,
718 },
719 )
720 }
721
722 fn paint(
723 &mut self,
724 bounds: gpui::geometry::rect::RectF,
725 visible_bounds: gpui::geometry::rect::RectF,
726 layout: &mut Self::LayoutState,
727 cx: &mut gpui::PaintContext,
728 ) -> Self::PaintState {
729 //Setup element stuff
730 let clip_bounds = Some(visible_bounds);
731
732 cx.paint_layer(clip_bounds, |cx| {
733 let origin = bounds.origin() + vec2f(layout.size.cell_width, 0.);
734
735 //Elements are ephemeral, only at paint time do we know what could be clicked by a mouse
736 self.attach_mouse_handlers(origin, self.view.id(), visible_bounds, layout.mode, cx);
737
738 cx.scene.push_cursor_region(gpui::CursorRegion {
739 bounds,
740 style: if layout.hyperlink_tooltip.is_some() {
741 gpui::CursorStyle::PointingHand
742 } else {
743 gpui::CursorStyle::IBeam
744 },
745 });
746
747 cx.paint_layer(clip_bounds, |cx| {
748 //Start with a background color
749 cx.scene.push_quad(Quad {
750 bounds: RectF::new(bounds.origin(), bounds.size()),
751 background: Some(layout.background_color),
752 border: Default::default(),
753 corner_radius: 0.,
754 });
755
756 for rect in &layout.rects {
757 rect.paint(origin, layout, cx)
758 }
759 });
760
761 //Draw Highlighted Backgrounds
762 cx.paint_layer(clip_bounds, |cx| {
763 for (relative_highlighted_range, color) in layout.relative_highlighted_ranges.iter()
764 {
765 if let Some((start_y, highlighted_range_lines)) =
766 to_highlighted_range_lines(relative_highlighted_range, layout, origin)
767 {
768 let hr = HighlightedRange {
769 start_y, //Need to change this
770 line_height: layout.size.line_height,
771 lines: highlighted_range_lines,
772 color: color.clone(),
773 //Copied from editor. TODO: move to theme or something
774 corner_radius: 0.15 * layout.size.line_height,
775 };
776 hr.paint(bounds, cx.scene);
777 }
778 }
779 });
780
781 //Draw the text cells
782 cx.paint_layer(clip_bounds, |cx| {
783 for cell in &layout.cells {
784 cell.paint(origin, layout, visible_bounds, cx);
785 }
786 });
787
788 //Draw cursor
789 if self.cursor_visible {
790 if let Some(cursor) = &layout.cursor {
791 cx.paint_layer(clip_bounds, |cx| {
792 cursor.paint(origin, cx);
793 })
794 }
795 }
796
797 if let Some(element) = &mut layout.hyperlink_tooltip {
798 element.paint(origin, visible_bounds, cx)
799 }
800 });
801 }
802
803 fn dispatch_event(
804 &mut self,
805 event: &gpui::Event,
806 _bounds: gpui::geometry::rect::RectF,
807 _visible_bounds: gpui::geometry::rect::RectF,
808 _layout: &mut Self::LayoutState,
809 _paint: &mut Self::PaintState,
810 cx: &mut gpui::EventContext,
811 ) -> bool {
812 if let Event::KeyDown(KeyDownEvent { keystroke, .. }) = event {
813 if !cx.is_parent_view_focused() {
814 return false;
815 }
816
817 if let Some(view) = self.view.upgrade(cx.app) {
818 view.update(cx.app, |view, cx| {
819 view.clear_bel(cx);
820 view.pause_cursor_blinking(cx);
821 })
822 }
823
824 self.terminal
825 .upgrade(cx.app)
826 .map(|model_handle| {
827 model_handle.update(cx.app, |term, cx| {
828 term.try_keystroke(
829 keystroke,
830 cx.global::<Settings>()
831 .terminal_overrides
832 .option_as_meta
833 .unwrap_or(false),
834 )
835 })
836 })
837 .unwrap_or(false)
838 } else {
839 false
840 }
841 }
842
843 fn metadata(&self) -> Option<&dyn std::any::Any> {
844 None
845 }
846
847 fn debug(
848 &self,
849 _bounds: gpui::geometry::rect::RectF,
850 _layout: &Self::LayoutState,
851 _paint: &Self::PaintState,
852 _cx: &gpui::DebugContext,
853 ) -> gpui::serde_json::Value {
854 json!({
855 "type": "TerminalElement",
856 })
857 }
858
859 fn rect_for_text_range(
860 &self,
861 _: Range<usize>,
862 bounds: RectF,
863 _: RectF,
864 layout: &Self::LayoutState,
865 _: &Self::PaintState,
866 _: &gpui::MeasurementContext,
867 ) -> Option<RectF> {
868 // Use the same origin that's passed to `Cursor::paint` in the paint
869 // method bove.
870 let mut origin = bounds.origin() + vec2f(layout.size.cell_width, 0.);
871
872 // TODO - Why is it necessary to move downward one line to get correct
873 // positioning? I would think that we'd want the same rect that is
874 // painted for the cursor.
875 origin += vec2f(0., layout.size.line_height);
876
877 Some(layout.cursor.as_ref()?.bounding_rect(origin))
878 }
879}
880
881fn is_blank(cell: &IndexedCell) -> bool {
882 if cell.c != ' ' {
883 return false;
884 }
885
886 if cell.bg != AnsiColor::Named(NamedColor::Background) {
887 return false;
888 }
889
890 if cell.hyperlink().is_some() {
891 return false;
892 }
893
894 if cell
895 .flags
896 .intersects(Flags::ALL_UNDERLINES | Flags::INVERSE | Flags::STRIKEOUT)
897 {
898 return false;
899 }
900
901 return true;
902}
903
904fn to_highlighted_range_lines(
905 range: &RangeInclusive<Point>,
906 layout: &LayoutState,
907 origin: Vector2F,
908) -> Option<(f32, Vec<HighlightedRangeLine>)> {
909 // Step 1. Normalize the points to be viewport relative.
910 // When display_offset = 1, here's how the grid is arranged:
911 //-2,0 -2,1...
912 //--- Viewport top
913 //-1,0 -1,1...
914 //--------- Terminal Top
915 // 0,0 0,1...
916 // 1,0 1,1...
917 //--- Viewport Bottom
918 // 2,0 2,1...
919 //--------- Terminal Bottom
920
921 // Normalize to viewport relative, from terminal relative.
922 // lines are i32s, which are negative above the top left corner of the terminal
923 // If the user has scrolled, we use the display_offset to tell us which offset
924 // of the grid data we should be looking at. But for the rendering step, we don't
925 // want negatives. We want things relative to the 'viewport' (the area of the grid
926 // which is currently shown according to the display offset)
927 let unclamped_start = Point::new(
928 range.start().line + layout.display_offset,
929 range.start().column,
930 );
931 let unclamped_end = Point::new(range.end().line + layout.display_offset, range.end().column);
932
933 // Step 2. Clamp range to viewport, and return None if it doesn't overlap
934 if unclamped_end.line.0 < 0 || unclamped_start.line.0 > layout.size.num_lines() as i32 {
935 return None;
936 }
937
938 let clamped_start_line = unclamped_start.line.0.max(0) as usize;
939 let clamped_end_line = unclamped_end.line.0.min(layout.size.num_lines() as i32) as usize;
940 //Convert the start of the range to pixels
941 let start_y = origin.y() + clamped_start_line as f32 * layout.size.line_height;
942
943 // Step 3. Expand ranges that cross lines into a collection of single-line ranges.
944 // (also convert to pixels)
945 let mut highlighted_range_lines = Vec::new();
946 for line in clamped_start_line..=clamped_end_line {
947 let mut line_start = 0;
948 let mut line_end = layout.size.columns();
949
950 if line == clamped_start_line {
951 line_start = unclamped_start.column.0 as usize;
952 }
953 if line == clamped_end_line {
954 line_end = unclamped_end.column.0 as usize + 1; //+1 for inclusive
955 }
956
957 highlighted_range_lines.push(HighlightedRangeLine {
958 start_x: origin.x() + line_start as f32 * layout.size.cell_width,
959 end_x: origin.x() + line_end as f32 * layout.size.cell_width,
960 });
961 }
962
963 Some((start_y, highlighted_range_lines))
964}