1use std::cmp::{max, min};
2use std::iter::repeat;
3
4use alacritty_terminal::grid::Dimensions;
5/// Most of the code, and specifically the constants, in this are copied from Alacritty,
6/// with modifications for our circumstances
7use alacritty_terminal::index::{Column as GridCol, Line as GridLine, Point, Side};
8use alacritty_terminal::term::TermMode;
9use gpui::scene::MouseScrollWheel;
10use gpui::{geometry::vector::Vector2F, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
11
12use crate::TerminalSize;
13
14struct Modifiers {
15 ctrl: bool,
16 shift: bool,
17 alt: bool,
18}
19
20impl Modifiers {
21 fn from_moved(e: &MouseMovedEvent) -> Self {
22 Modifiers {
23 ctrl: e.ctrl,
24 shift: e.shift,
25 alt: e.alt,
26 }
27 }
28
29 fn from_button(e: &MouseButtonEvent) -> Self {
30 Modifiers {
31 ctrl: e.ctrl,
32 shift: e.shift,
33 alt: e.alt,
34 }
35 }
36
37 fn from_scroll(scroll: &ScrollWheelEvent) -> Self {
38 Modifiers {
39 ctrl: scroll.ctrl,
40 shift: scroll.shift,
41 alt: scroll.alt,
42 }
43 }
44}
45
46enum MouseFormat {
47 SGR,
48 Normal(bool),
49}
50
51impl MouseFormat {
52 fn from_mode(mode: TermMode) -> Self {
53 if mode.contains(TermMode::SGR_MOUSE) {
54 MouseFormat::SGR
55 } else if mode.contains(TermMode::UTF8_MOUSE) {
56 MouseFormat::Normal(true)
57 } else {
58 MouseFormat::Normal(false)
59 }
60 }
61}
62
63#[derive(Debug)]
64enum MouseButton {
65 LeftButton = 0,
66 MiddleButton = 1,
67 RightButton = 2,
68 LeftMove = 32,
69 MiddleMove = 33,
70 RightMove = 34,
71 NoneMove = 35,
72 ScrollUp = 64,
73 ScrollDown = 65,
74 Other = 99,
75}
76
77impl MouseButton {
78 fn from_move(e: &MouseMovedEvent) -> Self {
79 match e.pressed_button {
80 Some(b) => match b {
81 gpui::MouseButton::Left => MouseButton::LeftMove,
82 gpui::MouseButton::Middle => MouseButton::MiddleMove,
83 gpui::MouseButton::Right => MouseButton::RightMove,
84 gpui::MouseButton::Navigate(_) => MouseButton::Other,
85 },
86 None => MouseButton::NoneMove,
87 }
88 }
89
90 fn from_button(e: &MouseButtonEvent) -> Self {
91 match e.button {
92 gpui::MouseButton::Left => MouseButton::LeftButton,
93 gpui::MouseButton::Right => MouseButton::MiddleButton,
94 gpui::MouseButton::Middle => MouseButton::RightButton,
95 gpui::MouseButton::Navigate(_) => MouseButton::Other,
96 }
97 }
98
99 fn from_scroll(e: &ScrollWheelEvent) -> Self {
100 if e.delta.raw().y() > 0. {
101 MouseButton::ScrollUp
102 } else {
103 MouseButton::ScrollDown
104 }
105 }
106
107 fn is_other(&self) -> bool {
108 match self {
109 MouseButton::Other => true,
110 _ => false,
111 }
112 }
113}
114
115pub fn scroll_report(
116 point: Point,
117 scroll_lines: i32,
118 e: &MouseScrollWheel,
119 mode: TermMode,
120) -> Option<impl Iterator<Item = Vec<u8>>> {
121 if mode.intersects(TermMode::MOUSE_MODE) {
122 mouse_report(
123 point,
124 MouseButton::from_scroll(e),
125 true,
126 Modifiers::from_scroll(e),
127 MouseFormat::from_mode(mode),
128 )
129 .map(|report| repeat(report).take(max(scroll_lines, 1) as usize))
130 } else {
131 None
132 }
133}
134
135pub fn alt_scroll(scroll_lines: i32) -> Vec<u8> {
136 let cmd = if scroll_lines > 0 { b'A' } else { b'B' };
137
138 let mut content = Vec::with_capacity(scroll_lines.abs() as usize * 3);
139 for _ in 0..scroll_lines.abs() {
140 content.push(0x1b);
141 content.push(b'O');
142 content.push(cmd);
143 }
144 content
145}
146
147pub fn mouse_button_report(
148 point: Point,
149 e: &MouseButtonEvent,
150 pressed: bool,
151 mode: TermMode,
152) -> Option<Vec<u8>> {
153 let button = MouseButton::from_button(e);
154 if !button.is_other() && mode.intersects(TermMode::MOUSE_MODE) {
155 mouse_report(
156 point,
157 button,
158 pressed,
159 Modifiers::from_button(e),
160 MouseFormat::from_mode(mode),
161 )
162 } else {
163 None
164 }
165}
166
167pub fn mouse_moved_report(point: Point, e: &MouseMovedEvent, mode: TermMode) -> Option<Vec<u8>> {
168 let button = MouseButton::from_move(e);
169
170 if !button.is_other() && mode.intersects(TermMode::MOUSE_MOTION | TermMode::MOUSE_DRAG) {
171 //Only drags are reported in drag mode, so block NoneMove.
172 if mode.contains(TermMode::MOUSE_DRAG) && matches!(button, MouseButton::NoneMove) {
173 None
174 } else {
175 mouse_report(
176 point,
177 button,
178 true,
179 Modifiers::from_moved(e),
180 MouseFormat::from_mode(mode),
181 )
182 }
183 } else {
184 None
185 }
186}
187
188pub fn mouse_side(pos: Vector2F, cur_size: TerminalSize) -> alacritty_terminal::index::Direction {
189 let x = pos.0.x() as usize;
190 let cell_x = x.saturating_sub(cur_size.cell_width as usize) % cur_size.cell_width as usize;
191 let half_cell_width = (cur_size.cell_width / 2.0) as usize;
192 let additional_padding = (cur_size.width() - cur_size.cell_width * 2.) % cur_size.cell_width;
193 let end_of_grid = cur_size.width() - cur_size.cell_width - additional_padding;
194 //Width: Pixels or columns?
195 if cell_x > half_cell_width
196 // Edge case when mouse leaves the window.
197 || x as f32 >= end_of_grid
198 {
199 Side::Right
200 } else {
201 Side::Left
202 }
203}
204
205pub fn grid_point(pos: Vector2F, cur_size: TerminalSize, display_offset: usize) -> Point {
206 let col = pos.x() / cur_size.cell_width;
207 let col = min(GridCol(col as usize), cur_size.last_column());
208 let line = pos.y() / cur_size.line_height;
209 let line = min(line as i32, cur_size.bottommost_line().0);
210 Point::new(GridLine(line - display_offset as i32), col)
211}
212
213///Generate the bytes to send to the terminal, from the cell location, a mouse event, and the terminal mode
214fn mouse_report(
215 point: Point,
216 button: MouseButton,
217 pressed: bool,
218 modifiers: Modifiers,
219 format: MouseFormat,
220) -> Option<Vec<u8>> {
221 if point.line < 0 {
222 return None;
223 }
224
225 let mut mods = 0;
226 if modifiers.shift {
227 mods += 4;
228 }
229 if modifiers.alt {
230 mods += 8;
231 }
232 if modifiers.ctrl {
233 mods += 16;
234 }
235
236 match format {
237 MouseFormat::SGR => {
238 Some(sgr_mouse_report(point, button as u8 + mods, pressed).into_bytes())
239 }
240 MouseFormat::Normal(utf8) => {
241 if pressed {
242 normal_mouse_report(point, button as u8 + mods, utf8)
243 } else {
244 normal_mouse_report(point, 3 + mods, utf8)
245 }
246 }
247 }
248}
249
250fn normal_mouse_report(point: Point, button: u8, utf8: bool) -> Option<Vec<u8>> {
251 let Point { line, column } = point;
252 let max_point = if utf8 { 2015 } else { 223 };
253
254 if line >= max_point || column >= max_point {
255 return None;
256 }
257
258 let mut msg = vec![b'\x1b', b'[', b'M', 32 + button];
259
260 let mouse_pos_encode = |pos: usize| -> Vec<u8> {
261 let pos = 32 + 1 + pos;
262 let first = 0xC0 + pos / 64;
263 let second = 0x80 + (pos & 63);
264 vec![first as u8, second as u8]
265 };
266
267 if utf8 && column >= 95 {
268 msg.append(&mut mouse_pos_encode(column.0));
269 } else {
270 msg.push(32 + 1 + column.0 as u8);
271 }
272
273 if utf8 && line >= 95 {
274 msg.append(&mut mouse_pos_encode(line.0 as usize));
275 } else {
276 msg.push(32 + 1 + line.0 as u8);
277 }
278
279 Some(msg)
280}
281
282fn sgr_mouse_report(point: Point, button: u8, pressed: bool) -> String {
283 let c = if pressed { 'M' } else { 'm' };
284
285 let msg = format!(
286 "\x1b[<{};{};{}{}",
287 button,
288 point.column + 1,
289 point.line + 1,
290 c
291 );
292
293 msg
294}
295
296#[cfg(test)]
297mod test {
298 use crate::mappings::mouse::grid_point;
299
300 #[test]
301 fn test_mouse_to_selection() {
302 let term_width = 100.;
303 let term_height = 200.;
304 let cell_width = 10.;
305 let line_height = 20.;
306 let mouse_pos_x = 100.; //Window relative
307 let mouse_pos_y = 100.; //Window relative
308 let origin_x = 10.;
309 let origin_y = 20.;
310
311 let cur_size = crate::TerminalSize::new(
312 line_height,
313 cell_width,
314 gpui::geometry::vector::vec2f(term_width, term_height),
315 );
316
317 let mouse_pos = gpui::geometry::vector::vec2f(mouse_pos_x, mouse_pos_y);
318 let origin = gpui::geometry::vector::vec2f(origin_x, origin_y); //Position of terminal window, 1 'cell' in
319 let mouse_pos = mouse_pos - origin;
320 let point = grid_point(mouse_pos, cur_size, 0);
321 assert_eq!(
322 point,
323 alacritty_terminal::index::Point::new(
324 alacritty_terminal::index::Line(((mouse_pos_y - origin_y) / line_height) as i32),
325 alacritty_terminal::index::Column(((mouse_pos_x - origin_x) / cell_width) as usize),
326 )
327 );
328 }
329}