794 lines
26 KiB
Rust
794 lines
26 KiB
Rust
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<TerminalConnection>,
|
|
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<LayoutCell>,
|
|
highlighted_range: Option<Range<usize>>,
|
|
}
|
|
|
|
///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<i32, i32>,
|
|
text: Line, //NOTE TO SELF THIS IS BAD PERFORMANCE RN!
|
|
background_color: Color,
|
|
}
|
|
|
|
impl LayoutCell {
|
|
fn new(point: Point<i32, i32>, 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<LayoutLine>,
|
|
line_height: LineHeight,
|
|
em_width: CellWidth,
|
|
cursor: Option<Cursor>,
|
|
background_color: Color,
|
|
cur_size: SizeInfo,
|
|
terminal: Arc<FairMutex<Term<ZedListener>>>,
|
|
selection_color: Color,
|
|
}
|
|
|
|
impl TerminalEl {
|
|
pub fn new(
|
|
view_id: usize,
|
|
connection: WeakModelHandle<TerminalConnection>,
|
|
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::<Settings>());
|
|
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::<Settings>()).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::<Vec<HighlightedRangeLine>>();
|
|
|
|
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| 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<Cell>,
|
|
text_style: &TextStyle,
|
|
terminal_theme: &TerminalStyle,
|
|
text_layout_cache: &TextLayoutCache,
|
|
modal: bool,
|
|
selection_range: Option<SelectionRange>,
|
|
) -> Vec<LayoutLine> {
|
|
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::<Vec<LayoutCell>>();
|
|
|
|
LayoutLine {
|
|
cells,
|
|
highlighted_range,
|
|
}
|
|
})
|
|
.collect::<Vec<LayoutLine>>()
|
|
}
|
|
|
|
// 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<FairMutex<Term<ZedListener>>>,
|
|
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),
|
|
)
|
|
);
|
|
}
|
|
}
|