use alacritty_terminal::{ grid::{Dimensions, GridIterator, Indexed, Scroll}, index::{Column as GridCol, Line as GridLine, Point, Side}, selection::{Selection, SelectionRange, SelectionType}, sync::FairMutex, term::{ cell::{Cell, Flags}, SizeInfo, }, Term, }; use editor::{Cursor, CursorShape, HighlightedRange, HighlightedRangeLine}; use gpui::{ color::Color, elements::*, fonts::{TextStyle, Underline}, geometry::{ rect::RectF, vector::{vec2f, Vector2F}, }, json::json, text_layout::{Line, RunStyle}, Event, FontCache, KeyDownEvent, MouseRegion, PaintContext, Quad, ScrollWheelEvent, SizeConstraint, TextLayoutCache, WeakModelHandle, }; use itertools::Itertools; use ordered_float::OrderedFloat; use settings::Settings; use theme::TerminalStyle; use util::ResultExt; use std::{cmp::min, ops::Range, rc::Rc, sync::Arc}; use std::{fmt::Debug, ops::Sub}; use crate::{color_translation::convert_color, connection::TerminalConnection, ZedListener}; ///Scrolling is unbearably sluggish by default. Alacritty supports a configurable ///Scroll multiplier that is set to 3 by default. This will be removed when I ///Implement scroll bars. const ALACRITTY_SCROLL_MULTIPLIER: f32 = 3.; ///Used to display the grid as passed to Alacritty and the TTY. ///Useful for debugging inconsistencies between behavior and display #[cfg(debug_assertions)] const DEBUG_GRID: bool = false; ///The GPUI element that paints the terminal. ///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? pub struct TerminalEl { connection: WeakModelHandle, view_id: usize, modal: bool, } ///New type pattern so I don't mix these two up struct CellWidth(f32); struct LineHeight(f32); struct LayoutLine { cells: Vec, highlighted_range: Option>, } ///New type pattern to ensure that we use adjusted mouse positions throughout the code base, rather than struct PaneRelativePos(Vector2F); ///Functionally the constructor for the PaneRelativePos type, mutates the mouse_position fn relative_pos(mouse_position: Vector2F, origin: Vector2F) -> PaneRelativePos { PaneRelativePos(mouse_position.sub(origin)) //Avoid the extra allocation by mutating } #[derive(Clone, Debug, Default)] struct LayoutCell { point: Point, text: Line, //NOTE TO SELF THIS IS BAD PERFORMANCE RN! background_color: Color, } impl LayoutCell { fn new(point: Point, text: Line, background_color: Color) -> LayoutCell { LayoutCell { point, text, background_color, } } } ///The information generated during layout that is nescessary for painting pub struct LayoutState { layout_lines: Vec, line_height: LineHeight, em_width: CellWidth, cursor: Option, background_color: Color, cur_size: SizeInfo, terminal: Arc>>, selection_color: Color, } impl TerminalEl { pub fn new( view_id: usize, connection: WeakModelHandle, modal: bool, ) -> TerminalEl { TerminalEl { view_id, connection, modal, } } } impl Element for TerminalEl { type LayoutState = LayoutState; type PaintState = (); fn layout( &mut self, constraint: gpui::SizeConstraint, cx: &mut gpui::LayoutContext, ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) { //Settings immutably borrows cx here for the settings and font cache //and we need to modify the cx to resize the terminal. So instead of //storing Settings or the font_cache(), we toss them ASAP and then reborrow later let text_style = make_text_style(cx.font_cache(), cx.global::()); let line_height = LineHeight(cx.font_cache().line_height(text_style.font_size)); let cell_width = CellWidth( cx.font_cache() .em_advance(text_style.font_id, text_style.font_size), ); let connection_handle = self.connection.upgrade(cx).unwrap(); //Tell the view our new size. Requires a mutable borrow of cx and the view let cur_size = make_new_size(constraint, &cell_width, &line_height); //Note that set_size locks and mutates the terminal. connection_handle.update(cx.app, |connection, _| connection.set_size(cur_size)); let (selection_color, terminal_theme) = { let theme = &(cx.global::()).theme; (theme.editor.selection.selection, &theme.terminal) }; let terminal_mutex = connection_handle.read(cx).term.clone(); let term = terminal_mutex.lock(); let grid = term.grid(); let cursor_point = grid.cursor.point; let cursor_text = grid[cursor_point.line][cursor_point.column].c.to_string(); let content = term.renderable_content(); let layout_lines = layout_lines( content.display_iter, &text_style, terminal_theme, cx.text_layout_cache, self.modal, content.selection, ); let block_text = cx.text_layout_cache.layout_str( &cursor_text, text_style.font_size, &[( cursor_text.len(), RunStyle { font_id: text_style.font_id, color: terminal_theme.colors.background, underline: Default::default(), }, )], ); let cursor = get_cursor_shape( content.cursor.point.line.0 as usize, content.cursor.point.column.0 as usize, content.display_offset, &line_height, &cell_width, cur_size.total_lines(), &block_text, ) .map(move |(cursor_position, block_width)| { let block_width = if block_width != 0.0 { block_width } else { cell_width.0 }; Cursor::new( cursor_position, block_width, line_height.0, terminal_theme.colors.cursor, CursorShape::Block, Some(block_text.clone()), ) }); drop(term); let background_color = if self.modal { terminal_theme.colors.modal_background } else { terminal_theme.colors.background }; ( constraint.max, LayoutState { layout_lines, line_height, em_width: cell_width, cursor, cur_size, background_color, terminal: terminal_mutex, selection_color, }, ) } fn paint( &mut self, bounds: gpui::geometry::rect::RectF, visible_bounds: gpui::geometry::rect::RectF, layout: &mut Self::LayoutState, cx: &mut gpui::PaintContext, ) -> Self::PaintState { //Setup element stuff let clip_bounds = Some(visible_bounds); cx.paint_layer(clip_bounds, |cx| { let cur_size = layout.cur_size.clone(); let origin = bounds.origin() + vec2f(layout.em_width.0, 0.); //Elements are ephemeral, only at paint time do we know what could be clicked by a mouse attach_mouse_handlers( origin, cur_size, self.view_id, &layout.terminal, visible_bounds, cx, ); cx.paint_layer(clip_bounds, |cx| { //Start with a background color cx.scene.push_quad(Quad { bounds: RectF::new(bounds.origin(), bounds.size()), background: Some(layout.background_color), border: Default::default(), corner_radius: 0., }); //Draw cell backgrounds for layout_line in &layout.layout_lines { for layout_cell in &layout_line.cells { let position = vec2f( (origin.x() + layout_cell.point.column as f32 * layout.em_width.0) .floor(), origin.y() + layout_cell.point.line as f32 * layout.line_height.0, ); let size = vec2f(layout.em_width.0.ceil(), layout.line_height.0); cx.scene.push_quad(Quad { bounds: RectF::new(position, size), background: Some(layout_cell.background_color), border: Default::default(), corner_radius: 0., }) } } }); //Draw Selection cx.paint_layer(clip_bounds, |cx| { let mut highlight_y = None; let highlight_lines = layout .layout_lines .iter() .filter_map(|line| { if let Some(range) = &line.highlighted_range { if let None = highlight_y { highlight_y = Some( origin.y() + line.cells[0].point.line as f32 * layout.line_height.0, ); } let start_x = origin.x() + line.cells[range.start].point.column as f32 * layout.em_width.0; let end_x = origin.x() + line.cells[range.end].point.column as f32 * layout.em_width.0 + layout.em_width.0; return Some(HighlightedRangeLine { start_x, end_x }); } else { return None; } }) .collect::>(); if let Some(y) = highlight_y { let hr = HighlightedRange { start_y: y, //Need to change this line_height: layout.line_height.0, lines: highlight_lines, color: layout.selection_color, //Copied from editor. TODO: move to theme or something corner_radius: 0.15 * layout.line_height.0, }; hr.paint(bounds, cx.scene); } }); cx.paint_layer(clip_bounds, |cx| { for layout_line in &layout.layout_lines { for layout_cell in &layout_line.cells { let point = layout_cell.point; //Don't actually know the start_x for a line, until here: let cell_origin = vec2f( (origin.x() + point.column as f32 * layout.em_width.0).floor(), origin.y() + point.line as f32 * layout.line_height.0, ); layout_cell.text.paint( cell_origin, visible_bounds, layout.line_height.0, cx, ); } } }); //Draw cursor if let Some(cursor) = &layout.cursor { cx.paint_layer(clip_bounds, |cx| { cursor.paint(origin, cx); }) } #[cfg(debug_assertions)] if DEBUG_GRID { cx.paint_layer(clip_bounds, |cx| { draw_debug_grid(bounds, layout, cx); }) } }); } fn dispatch_event( &mut self, event: &gpui::Event, _bounds: gpui::geometry::rect::RectF, visible_bounds: gpui::geometry::rect::RectF, layout: &mut Self::LayoutState, _paint: &mut Self::PaintState, cx: &mut gpui::EventContext, ) -> bool { match event { Event::ScrollWheel(ScrollWheelEvent { delta, position, .. }) => visible_bounds .contains_point(*position) .then(|| { let vertical_scroll = (delta.y() / layout.line_height.0) * ALACRITTY_SCROLL_MULTIPLIER; if let Some(connection) = self.connection.upgrade(cx.app) { connection.update(cx.app, |connection, _| { connection .term .lock() .scroll_display(Scroll::Delta(vertical_scroll.round() as i32)); }) } }) .is_some(), Event::KeyDown(KeyDownEvent { keystroke, .. }) => { if !cx.is_parent_view_focused() { return false; } self.connection .upgrade(cx.app) .map(|connection| { connection .update(cx.app, |connection, _| connection.try_keystroke(keystroke)) }) .unwrap_or(false) } _ => false, } } fn debug( &self, _bounds: gpui::geometry::rect::RectF, _layout: &Self::LayoutState, _paint: &Self::PaintState, _cx: &gpui::DebugContext, ) -> gpui::serde_json::Value { json!({ "type": "TerminalElement", }) } } pub fn mouse_to_cell_data( pos: Vector2F, origin: Vector2F, cur_size: SizeInfo, display_offset: usize, ) -> (Point, alacritty_terminal::index::Direction) { let relative_pos = relative_pos(pos, origin); let point = grid_cell(&relative_pos, cur_size, display_offset); let side = cell_side(&relative_pos, cur_size); (point, side) } ///Configures a text style from the current settings. fn make_text_style(font_cache: &FontCache, settings: &Settings) -> TextStyle { // Pull the font family from settings properly overriding let family_id = settings .terminal_overrides .font_family .as_ref() .and_then(|family_name| dbg!(font_cache.load_family(&[family_name]).log_err())) .or_else(|| { settings .terminal_defaults .font_family .as_ref() .and_then(|family_name| font_cache.load_family(&[family_name]).log_err()) }) .unwrap_or(settings.buffer_font_family); TextStyle { color: settings.theme.editor.text_color, font_family_id: family_id, font_family_name: font_cache.family_name(family_id).unwrap(), font_id: font_cache .select_font(family_id, &Default::default()) .unwrap(), font_size: settings .terminal_overrides .font_size .or(settings.terminal_defaults.font_size) .unwrap_or(settings.buffer_font_size), font_properties: Default::default(), underline: Default::default(), } } ///Configures a size info object from the given information. fn make_new_size( constraint: SizeConstraint, cell_width: &CellWidth, line_height: &LineHeight, ) -> SizeInfo { SizeInfo::new( constraint.max.x() - cell_width.0, constraint.max.y(), cell_width.0, line_height.0, 0., 0., false, ) } fn layout_lines( grid: GridIterator, text_style: &TextStyle, terminal_theme: &TerminalStyle, text_layout_cache: &TextLayoutCache, modal: bool, selection_range: Option, ) -> Vec { let lines = grid.group_by(|i| i.point.line); lines .into_iter() .enumerate() .map(|(line_index, (_, line))| { let mut highlighted_range = None; let cells = line .enumerate() .map(|(x_index, indexed_cell)| { if selection_range .map(|range| range.contains(indexed_cell.point)) .unwrap_or(false) { let mut range = highlighted_range.take().unwrap_or(x_index..x_index); range.end = range.end.max(x_index); highlighted_range = Some(range); } let cell_text = &indexed_cell.c.to_string(); let cell_style = cell_style(&indexed_cell, terminal_theme, text_style, modal); //This is where we might be able to get better performance let layout_cell = text_layout_cache.layout_str( cell_text, text_style.font_size, &[(cell_text.len(), cell_style)], ); LayoutCell::new( Point::new(line_index as i32, indexed_cell.point.column.0 as i32), layout_cell, convert_color(&indexed_cell.bg, &terminal_theme.colors, modal), ) }) .collect::>(); LayoutLine { cells, highlighted_range, } }) .collect::>() } // Compute the cursor position and expected block width, may return a zero width if x_for_index returns // the same position for sequential indexes. Use em_width instead //TODO: This function is messy, too many arguments and too many ifs. Simplify. fn get_cursor_shape( line: usize, line_index: usize, display_offset: usize, line_height: &LineHeight, cell_width: &CellWidth, total_lines: usize, text_fragment: &Line, ) -> Option<(Vector2F, f32)> { let cursor_line = line + display_offset; if cursor_line <= total_lines { let cursor_width = if text_fragment.width() == 0. { cell_width.0 } else { text_fragment.width() }; Some(( vec2f( line_index as f32 * cell_width.0, cursor_line as f32 * line_height.0, ), cursor_width, )) } else { None } } ///Convert the Alacritty cell styles to GPUI text styles and background color fn cell_style( indexed: &Indexed<&Cell>, style: &TerminalStyle, text_style: &TextStyle, modal: bool, ) -> RunStyle { let flags = indexed.cell.flags; let fg = convert_color(&indexed.cell.fg, &style.colors, modal); let underline = flags .contains(Flags::UNDERLINE) .then(|| Underline { color: Some(fg), squiggly: false, thickness: OrderedFloat(1.), }) .unwrap_or_default(); RunStyle { color: fg, font_id: text_style.font_id, underline, } } fn attach_mouse_handlers( origin: Vector2F, cur_size: SizeInfo, view_id: usize, terminal_mutex: &Arc>>, visible_bounds: RectF, cx: &mut PaintContext, ) { let click_mutex = terminal_mutex.clone(); let drag_mutex = terminal_mutex.clone(); let mouse_down_mutex = terminal_mutex.clone(); cx.scene.push_mouse_region(MouseRegion { view_id, mouse_down: Some(Rc::new(move |pos, _| { let mut term = mouse_down_mutex.lock(); let (point, side) = mouse_to_cell_data( pos, origin, cur_size, term.renderable_content().display_offset, ); term.selection = Some(Selection::new(SelectionType::Simple, point, side)) })), click: Some(Rc::new(move |pos, click_count, cx| { let mut term = click_mutex.lock(); let (point, side) = mouse_to_cell_data( pos, origin, cur_size, term.renderable_content().display_offset, ); let selection_type = match click_count { 0 => return, //This is a release 1 => Some(SelectionType::Simple), 2 => Some(SelectionType::Semantic), 3 => Some(SelectionType::Lines), _ => None, }; let selection = selection_type.map(|selection_type| Selection::new(selection_type, point, side)); term.selection = selection; cx.focus_parent_view(); cx.notify(); })), bounds: visible_bounds, drag: Some(Rc::new(move |_delta, pos, cx| { let mut term = drag_mutex.lock(); let (point, side) = mouse_to_cell_data( pos, origin, cur_size, term.renderable_content().display_offset, ); if let Some(mut selection) = term.selection.take() { selection.update(point, side); term.selection = Some(selection); } cx.notify(); })), ..Default::default() }); } ///Copied (with modifications) from alacritty/src/input.rs > Processor::cell_side() fn cell_side(pos: &PaneRelativePos, cur_size: SizeInfo) -> Side { let x = pos.0.x() as usize; let cell_x = x.saturating_sub(cur_size.cell_width() as usize) % cur_size.cell_width() as usize; let half_cell_width = (cur_size.cell_width() / 2.0) as usize; let additional_padding = (cur_size.width() - cur_size.cell_width() * 2.) % cur_size.cell_width(); let end_of_grid = cur_size.width() - cur_size.cell_width() - additional_padding; if cell_x > half_cell_width // Edge case when mouse leaves the window. || x as f32 >= end_of_grid { Side::Right } else { Side::Left } } ///Copied (with modifications) from alacritty/src/event.rs > Mouse::point() ///Position is a pane-relative position. That means the top left corner of the mouse ///Region should be (0,0) fn grid_cell(pos: &PaneRelativePos, cur_size: SizeInfo, display_offset: usize) -> Point { let pos = pos.0; let col = pos.x() / cur_size.cell_width(); //TODO: underflow... let col = min(GridCol(col as usize), cur_size.last_column()); let line = pos.y() / cur_size.cell_height(); let line = min(line as i32, cur_size.bottommost_line().0); //when clicking, need to ADD to get to the top left cell //e.g. total_lines - viewport_height, THEN subtract display offset //0 -> total_lines - viewport_height - display_offset + mouse_line Point::new(GridLine(line - display_offset as i32), col) } ///Draws the grid as Alacritty sees it. Useful for checking if there is an inconsistency between ///Display and conceptual grid. #[cfg(debug_assertions)] fn draw_debug_grid(bounds: RectF, layout: &mut LayoutState, cx: &mut PaintContext) { let width = layout.cur_size.width(); let height = layout.cur_size.height(); //Alacritty uses 'as usize', so shall we. for col in 0..(width / layout.em_width.0).round() as usize { cx.scene.push_quad(Quad { bounds: RectF::new( bounds.origin() + vec2f((col + 1) as f32 * layout.em_width.0, 0.), vec2f(1., height), ), background: Some(Color::green()), border: Default::default(), corner_radius: 0., }); } for row in 0..((height / layout.line_height.0) + 1.0).round() as usize { cx.scene.push_quad(Quad { bounds: RectF::new( bounds.origin() + vec2f(layout.em_width.0, row as f32 * layout.line_height.0), vec2f(width, 1.), ), background: Some(Color::green()), border: Default::default(), corner_radius: 0., }); } } mod test { #[test] fn test_mouse_to_selection() { let term_width = 100.; let term_height = 200.; let cell_width = 10.; let line_height = 20.; let mouse_pos_x = 100.; //Window relative let mouse_pos_y = 100.; //Window relative let origin_x = 10.; let origin_y = 20.; let cur_size = alacritty_terminal::term::SizeInfo::new( term_width, term_height, cell_width, line_height, 0., 0., false, ); let mouse_pos = gpui::geometry::vector::vec2f(mouse_pos_x, mouse_pos_y); let origin = gpui::geometry::vector::vec2f(origin_x, origin_y); //Position of terminal window, 1 'cell' in let (point, _) = crate::terminal_element::mouse_to_cell_data(mouse_pos, origin, cur_size, 0); assert_eq!( point, alacritty_terminal::index::Point::new( alacritty_terminal::index::Line(((mouse_pos_y - origin_y) / line_height) as i32), alacritty_terminal::index::Column(((mouse_pos_x - origin_x) / cell_width) as usize), ) ); } #[test] fn test_mouse_to_selection_off_edge() { let term_width = 100.; let term_height = 200.; let cell_width = 10.; let line_height = 20.; let mouse_pos_x = 100.; //Window relative let mouse_pos_y = 100.; //Window relative let origin_x = 10.; let origin_y = 20.; let cur_size = alacritty_terminal::term::SizeInfo::new( term_width, term_height, cell_width, line_height, 0., 0., false, ); let mouse_pos = gpui::geometry::vector::vec2f(mouse_pos_x, mouse_pos_y); let origin = gpui::geometry::vector::vec2f(origin_x, origin_y); //Position of terminal window, 1 'cell' in let (point, _) = crate::terminal_element::mouse_to_cell_data(mouse_pos, origin, cur_size, 0); assert_eq!( point, alacritty_terminal::index::Point::new( alacritty_terminal::index::Line(((mouse_pos_y - origin_y) / line_height) as i32), alacritty_terminal::index::Column(((mouse_pos_x - origin_x) / cell_width) as usize), ) ); } }