1use crate::args::{MAX_FONT_SIZE, MIN_FONT_SIZE};
6use crate::colors::ColorScheme;
7use crate::terminal::Terminal;
8use crate::text_grid::{TextGridFacet, TextGridMessages};
9use anyhow::Error;
10use carnelian::drawing::load_font;
11use carnelian::render::Context as RenderContext;
12use carnelian::scene::facets::FacetId;
13use carnelian::scene::scene::{Scene, SceneBuilder, SceneOrder};
14use carnelian::{
15 AppSender, Point, Size, ViewAssistant, ViewAssistantContext, ViewAssistantPtr, ViewKey, input,
16};
17use fidl_fuchsia_hardware_power_statecontrol::{
18 AdminMarker, AdminSynchronousProxy, ShutdownAction, ShutdownOptions, ShutdownReason,
19};
20use fidl_fuchsia_hardware_pty::WindowSize;
21use fidl_fuchsia_input::ConsumerControlButton;
22use fuchsia_async as fasync;
23use fuchsia_component::client::connect_channel_to_protocol;
24use futures::future::{FutureExt as _, join_all};
25use pty::key_util::{CodePoint, HidUsage};
26use std::collections::{BTreeMap, BTreeSet};
27use std::io::Write as _;
28use std::mem;
29use std::path::PathBuf;
30use terminal::renderer::Rgb;
31use terminal::{FontSet, Scroll, SizeInfo, cell_size_from_cell_height, get_scale_factor};
32
33fn is_control_only(modifiers: &input::Modifiers) -> bool {
34 modifiers.control && !modifiers.shift && !modifiers.alt && !modifiers.caps_lock
35}
36
37fn get_input_sequence_for_key_event(
38 event: &input::keyboard::Event,
39 app_cursor: bool,
40) -> Option<String> {
41 match event.phase {
42 input::keyboard::Phase::Pressed | input::keyboard::Phase::Repeat => {
43 match event.code_point {
44 None => HidUsage { hid_usage: event.hid_usage, app_cursor }.into(),
45 Some(code_point) => CodePoint {
46 code_point: code_point,
47 control_pressed: is_control_only(&event.modifiers),
48 }
49 .into(),
50 }
51 }
52 _ => None,
53 }
54}
55
56pub enum ViewMessages {
57 AddTerminalMessage(u32, Terminal, bool),
58 RequestTerminalUpdateMessage(u32),
59}
60
61const MIN_TAB_WIDTH: usize = 16;
63const MAX_TAB_WIDTH: usize = 32;
64
65const STATUS_COLOR_DEFAULT: Rgb = Rgb { r: 170, g: 170, b: 170 };
67const STATUS_COLOR_ACTIVE: Rgb = Rgb { r: 255, g: 255, b: 85 };
68const STATUS_COLOR_UPDATED: Rgb = Rgb { r: 85, g: 255, b: 85 };
69
70const FONT_SIZE_INCREMENT: f32 = 4.0;
72
73const MAX_CELLS: u32 = SceneOrder::MAX.as_u32() / 4;
75
76struct SceneDetails {
77 scene: Scene,
78 textgrid: Option<FacetId>,
79}
80
81#[derive(Clone, Copy, Eq, PartialEq)]
82struct TerminalStatus {
83 pub has_output: bool,
84 pub at_top: bool,
85 pub at_bottom: bool,
86}
87
88struct RepeatedButtonPressHandler {
93 press_durations_ns: Vec<u64>,
98
99 down_times_ns: Vec<u64>,
102
103 button: ConsumerControlButton,
104
105 pending_down_time_ns: Option<u64>,
108}
109
110impl RepeatedButtonPressHandler {
111 pub fn new(button: ConsumerControlButton) -> Self {
112 Self {
113 press_durations_ns: vec![],
114 down_times_ns: vec![],
115 button,
116 pending_down_time_ns: None,
117 }
118 }
119
120 pub fn handle_button_event(
122 &mut self,
123 event: &input::consumer_control::Event,
124 time_ns: u64,
125 ) -> bool {
126 if event.button != self.button {
127 return false;
128 }
129
130 if event.phase == carnelian::input::consumer_control::Phase::Down {
131 self.pending_down_time_ns = Some(time_ns);
132 return true;
133 }
134
135 if let None = self.pending_down_time_ns {
137 return false;
138 }
139 let down_time_ns: u64 =
140 self.pending_down_time_ns.take().expect("pending press down time missing");
141 let up_time_ns: u64 = time_ns;
142
143 if up_time_ns < down_time_ns {
144 return false;
145 }
146 let press_duration_ns: u64 = up_time_ns - down_time_ns;
147
148 let last_down_time_ns: u64 = *self.down_times_ns.last().unwrap_or(&0);
149 if down_time_ns < last_down_time_ns {
150 return false;
151 }
152
153 const REPEATED_PRESS_THRESHOLD_NS: u64 =
154 zx::MonotonicDuration::from_seconds(2).into_nanos() as u64;
155
156 if down_time_ns - last_down_time_ns > REPEATED_PRESS_THRESHOLD_NS {
158 self.press_durations_ns = vec![press_duration_ns];
159 self.down_times_ns = vec![down_time_ns];
160 } else {
161 self.press_durations_ns.push(press_duration_ns);
162 self.down_times_ns.push(down_time_ns);
163 }
164
165 true
166 }
167}
168
169pub struct VirtualConsoleViewAssistant {
170 app_sender: AppSender,
171 view_key: ViewKey,
172 color_scheme: ColorScheme,
173 round_scene_corners: bool,
174 font_size: f32,
175 dpi: BTreeSet<u32>,
176 cell_size: Size,
177 tab_width: usize,
178 scene_details: Option<SceneDetails>,
179 terminals: BTreeMap<u32, (Terminal, TerminalStatus)>,
180 font_set: FontSet,
181 active_terminal_id: u32,
182 owns_display: bool,
183 active_pointer_id: Option<input::pointer::PointerId>,
184 start_pointer_location: Point,
185 power_button_press_handler: RepeatedButtonPressHandler,
186}
187
188const FONT: &'static str = "/pkg/data/font.ttf";
189const BOLD_FONT_PATH_1: &'static str = "/pkg/data/bold-font.ttf";
190const BOLD_FONT_PATH_2: &'static str = "/boot/data/bold-font.ttf";
191const ITALIC_FONT_PATH_1: &'static str = "/pkg/data/italic-font.ttf";
192const ITALIC_FONT_PATH_2: &'static str = "/boot/data/italic-font.ttf";
193const BOLD_ITALIC_FONT_PATH_1: &'static str = "/pkg/data/bold-italic-font.ttf";
194const BOLD_ITALIC_FONT_PATH_2: &'static str = "/boot/data/bold-italic-font.ttf";
195const FALLBACK_FONT_PREFIX: &'static str = "/pkg/data/fallback-font";
196
197impl VirtualConsoleViewAssistant {
198 pub fn new(
199 app_sender: &AppSender,
200 view_key: ViewKey,
201 color_scheme: ColorScheme,
202 round_scene_corners: bool,
203 font_size: f32,
204 dpi: BTreeSet<u32>,
205 ) -> Result<ViewAssistantPtr, Error> {
206 Ok(Box::new(Self::create(
207 app_sender,
208 view_key,
209 color_scheme,
210 round_scene_corners,
211 font_size,
212 dpi,
213 )?))
214 }
215
216 pub fn create(
217 app_sender: &AppSender,
218 view_key: ViewKey,
219 color_scheme: ColorScheme,
220 round_scene_corners: bool,
221 font_size: f32,
222 dpi: BTreeSet<u32>,
223 ) -> Result<VirtualConsoleViewAssistant, Error> {
224 let cell_size = Size::new(8.0, 16.0);
225 let tab_width = MIN_TAB_WIDTH;
226 let scene_details = None;
227 let terminals = BTreeMap::new();
228 let active_terminal_id = 0;
229 let font = load_font(PathBuf::from(FONT))?;
230 let bold_font = load_font(PathBuf::from(BOLD_FONT_PATH_1))
231 .or_else(|_| load_font(PathBuf::from(BOLD_FONT_PATH_2)))
232 .ok();
233 let italic_font = load_font(PathBuf::from(ITALIC_FONT_PATH_1))
234 .or_else(|_| load_font(PathBuf::from(ITALIC_FONT_PATH_2)))
235 .ok();
236 let bold_italic_font = load_font(PathBuf::from(BOLD_ITALIC_FONT_PATH_1))
237 .or_else(|_| load_font(PathBuf::from(BOLD_ITALIC_FONT_PATH_2)))
238 .ok();
239 let mut fallback_fonts = vec![];
240 while let Ok(font) = load_font(PathBuf::from(format!(
241 "{}-{}.ttf",
242 FALLBACK_FONT_PREFIX,
243 fallback_fonts.len() + 1
244 ))) {
245 fallback_fonts.push(font);
246 }
247 let font_set = FontSet::new(font, bold_font, italic_font, bold_italic_font, fallback_fonts);
248 let owns_display = true;
249 let active_pointer_id = None;
250 let start_pointer_location = Point::zero();
251 let power_button_press_handler =
252 RepeatedButtonPressHandler::new(ConsumerControlButton::Power);
253
254 Ok(VirtualConsoleViewAssistant {
255 app_sender: app_sender.clone(),
256 view_key,
257 color_scheme,
258 round_scene_corners,
259 font_size,
260 dpi,
261 cell_size,
262 tab_width,
263 scene_details,
264 terminals,
265 font_set,
266 active_terminal_id,
267 owns_display,
268 active_pointer_id,
269 start_pointer_location,
270 power_button_press_handler,
271 })
272 }
273
274 pub fn handle_ownership_change(&mut self, owned: bool) -> Result<(), Error> {
275 self.owns_display = owned;
276 if !owned {
277 self.active_pointer_id = None;
278 }
279 Ok(())
280 }
281
282 #[cfg(test)]
283 pub fn owns_display(&self) -> bool {
284 self.owns_display
285 }
286
287 #[cfg(test)]
288 pub fn active_terminal_id(&self) -> u32 {
289 self.active_terminal_id
290 }
291
292 #[cfg(test)]
293 pub fn active_pointer_id(&self) -> Option<input::pointer::PointerId> {
294 self.active_pointer_id.clone()
295 }
296
297 #[cfg(test)]
298 fn new_assistant_for_test() -> Result<VirtualConsoleViewAssistant, Error> {
299 let app_sender = AppSender::new_for_testing_purposes_only();
300 let dpi: BTreeSet<u32> = [160, 320, 480, 640].iter().cloned().collect();
301 Self::create(&app_sender, Default::default(), ColorScheme::default(), false, 14.0, dpi)
302 }
303
304 #[cfg(test)]
305 fn new_for_test() -> Result<ViewAssistantPtr, Error> {
306 Ok(Box::new(Self::new_assistant_for_test()?))
307 }
308
309 fn resize_terminals(&mut self, new_size: &Size, new_font_size: f32) {
311 let cell_size = cell_size_from_cell_height(&self.font_set, new_font_size);
312 let grid_size =
313 Size::new(new_size.width / cell_size.width, new_size.height / cell_size.height).floor();
314 let clamped_grid_size = if grid_size.area() > MAX_CELLS as f32 {
316 assert!(
317 grid_size.height <= MAX_CELLS as f32,
318 "terminal height greater than MAX_CELLS: {}",
319 grid_size.height
320 );
321 Size::new(MAX_CELLS as f32 / grid_size.height, grid_size.height).floor()
322 } else {
323 grid_size
324 };
325 let clamped_size = Size::new(
326 clamped_grid_size.width * cell_size.width,
327 clamped_grid_size.height * cell_size.height,
328 );
329 let size = Size::new(clamped_size.width, clamped_size.height - cell_size.height);
330 let size_info = SizeInfo {
331 width: size.width,
332 height: size.height,
333 cell_width: cell_size.width,
334 cell_height: cell_size.height,
335 padding_x: 0.0,
336 padding_y: 0.0,
337 dpr: 1.0,
338 };
339
340 self.cell_size = cell_size;
341
342 for (terminal, _) in self.terminals.values_mut() {
343 terminal.resize(&size_info);
344 }
345
346 let window_size = WindowSize {
348 width: clamped_grid_size.width as u32,
349 height: clamped_grid_size.height as u32 - 1,
350 };
351
352 let ptys: Vec<_> =
353 self.terminals.values().filter_map(|(term, _)| term.pty()).cloned().collect();
354 fasync::Task::local(async move {
355 join_all(ptys.iter().map(|pty| {
356 pty.resize(window_size).map(|result| result.expect("failed to set window size"))
357 }))
358 .map(|vec| vec.into_iter().collect())
359 .await
360 })
361 .detach();
362 }
363
364 fn get_status(&self) -> Vec<(String, Rgb)> {
367 self.terminals
368 .iter()
369 .map(|(id, (t, status))| {
370 let fg = if *id == self.active_terminal_id {
371 STATUS_COLOR_ACTIVE
372 } else if status.has_output {
373 STATUS_COLOR_UPDATED
374 } else {
375 STATUS_COLOR_DEFAULT
376 };
377
378 let left = if status.at_top { '[' } else { '<' };
379 let right = if status.at_bottom { ']' } else { '>' };
380
381 (format!("{}{}{} {}", left, *id, right, t.title()), fg)
382 })
383 .collect()
384 }
385
386 fn set_active_terminal(&mut self, id: u32) {
387 if let Some((terminal, status)) = self.terminals.get_mut(&id) {
388 self.active_terminal_id = id;
389 status.has_output = false;
390 let terminal = terminal.clone_term();
391 let new_status = self.get_status();
392 if let Some(scene_details) = &mut self.scene_details {
393 if let Some(textgrid) = &scene_details.textgrid {
394 scene_details.scene.send_message(
395 textgrid,
396 Box::new(TextGridMessages::ChangeStatusMessage(new_status)),
397 );
398 scene_details.scene.send_message(
399 textgrid,
400 Box::new(TextGridMessages::SetTermMessage(terminal)),
401 );
402 self.app_sender.request_render(self.view_key);
403 }
404 }
405 }
406 }
407
408 fn next_active_terminal(&mut self) {
409 let first = self.terminals.keys().next();
410 let last = self.terminals.keys().next_back();
411 if let Some((first, last)) = first.and_then(|first| last.map(|last| (first, last))) {
412 let active = self.active_terminal_id;
413 let id = if active == *last { *first } else { active + 1 };
414 self.set_active_terminal(id);
415 }
416 }
417
418 fn previous_active_terminal(&mut self) {
419 let first = self.terminals.keys().next();
420 let last = self.terminals.keys().next_back();
421 if let Some((first, last)) = first.and_then(|first| last.map(|last| (first, last))) {
422 let active = self.active_terminal_id;
423 let id = if active == *first { *last } else { active - 1 };
424 self.set_active_terminal(id);
425 }
426 }
427
428 fn update_status(&mut self) {
429 let new_status = self.get_status();
430 if let Some(scene_details) = &mut self.scene_details {
431 if let Some(textgrid) = &scene_details.textgrid {
432 scene_details.scene.send_message(
433 textgrid,
434 Box::new(TextGridMessages::ChangeStatusMessage(new_status)),
435 );
436 self.app_sender.request_render(self.view_key);
437 }
438 }
439 }
440
441 fn set_font_size(&mut self, font_size: f32) {
442 self.font_size = font_size;
443 self.scene_details = None;
444 self.app_sender.request_render(self.view_key);
445 }
446
447 fn scroll_active_terminal(&mut self, scroll: Scroll) {
448 if let Some((terminal, _)) = self.terminals.get_mut(&self.active_terminal_id) {
449 terminal.scroll(scroll);
450 }
451 }
452
453 fn trigger_shutdown(&mut self, shutdown_action: ShutdownAction) -> Result<(), Error> {
454 let (tx, rx) = std::sync::mpsc::channel();
455 std::thread::spawn(move || {
456 let res = (|| {
457 let (server_end, client_end) = zx::Channel::create();
458 connect_channel_to_protocol::<AdminMarker>(server_end)?;
459 let admin = AdminSynchronousProxy::new(client_end);
460 Ok(admin.shutdown(
461 &ShutdownOptions {
462 action: Some(shutdown_action),
463 reasons: Some(vec![ShutdownReason::DeveloperRequest]),
464 ..Default::default()
465 },
466 zx::MonotonicInstant::INFINITE,
467 )?)
468 })();
469 let _ = tx.send(res);
470 });
471
472 match rx.recv_timeout(std::time::Duration::from_secs(5)) {
473 Ok(Ok(Ok(()))) => {
474 println!("Shutdown call returned unexpectedly, sleeping forever.");
475 zx::MonotonicInstant::INFINITE.sleep();
476 }
477 Ok(Ok(Err(e))) => println!("Failed to shutdown, status: {}", e),
478 Ok(Err(e)) => return Err(e),
479 Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
480 println!("Failed to shutdown due to timeout.");
481 }
482 Err(_) => panic!("Background shutdown thread terminated unexpectedly."),
483 }
484 Ok(())
485 }
486
487 fn handle_device_control_consumer_control_event(
488 &mut self,
489 _context: &mut ViewAssistantContext,
490 consumer_control_event: &input::consumer_control::Event,
491 event_time_ns: u64,
492 ) -> Result<bool, Error> {
493 let power_button_press_handled = self
494 .power_button_press_handler
495 .handle_button_event(consumer_control_event, event_time_ns);
496 if power_button_press_handled {
497 const POWER_KEY_PRESS_COUNT_FOR_REBOOT: usize = 3;
498 if self.power_button_press_handler.press_durations_ns.len()
499 >= POWER_KEY_PRESS_COUNT_FOR_REBOOT
500 {
501 let last_press_duration =
502 *self.power_button_press_handler.press_durations_ns.last().expect("last");
503
504 const REBOOT_TO_BOOTLOADER_THRESHOLD: u64 =
505 zx::MonotonicDuration::from_seconds(1).into_nanos() as u64;
506
507 if last_press_duration > REBOOT_TO_BOOTLOADER_THRESHOLD {
508 self.trigger_shutdown(ShutdownAction::RebootToBootloader)?;
509 } else {
510 self.trigger_shutdown(ShutdownAction::Reboot)?;
511 }
512 }
513 return Ok(true);
514 }
515
516 Ok(false)
517 }
518
519 fn handle_device_control_keyboard_event(
520 &mut self,
521 _context: &mut ViewAssistantContext,
522 keyboard_event: &input::keyboard::Event,
523 ) -> Result<bool, Error> {
524 if keyboard_event.phase == input::keyboard::Phase::Pressed {
525 if keyboard_event.code_point.is_none() {
526 const HID_USAGE_KEY_DELETE: u32 = 0x4c;
527
528 let modifiers = &keyboard_event.modifiers;
529 match keyboard_event.hid_usage {
530 HID_USAGE_KEY_DELETE if modifiers.control && modifiers.alt => {
532 self.trigger_shutdown(ShutdownAction::Reboot)?;
533 return Ok(true);
534 }
535 _ => {}
536 }
537 }
538 }
539
540 Ok(false)
541 }
542
543 fn handle_control_keyboard_event(
544 &mut self,
545 _context: &mut ViewAssistantContext,
546 keyboard_event: &input::keyboard::Event,
547 ) -> Result<bool, Error> {
548 match keyboard_event.phase {
549 input::keyboard::Phase::Pressed | input::keyboard::Phase::Repeat => {
550 let modifiers = &keyboard_event.modifiers;
551 match keyboard_event.code_point {
552 None => {
553 const HID_USAGE_KEY_TAB: u32 = 0x2b;
554 const HID_USAGE_KEY_F1: u32 = 0x3a;
555 const HID_USAGE_KEY_F10: u32 = 0x43;
556 const HID_USAGE_KEY_HOME: u32 = 0x4a;
557 const HID_USAGE_KEY_PAGEUP: u32 = 0x4b;
558 const HID_USAGE_KEY_END: u32 = 0x4d;
559 const HID_USAGE_KEY_PAGEDOWN: u32 = 0x4e;
560 const HID_USAGE_KEY_DOWN: u32 = 0x51;
561 const HID_USAGE_KEY_UP: u32 = 0x52;
562 const HID_USAGE_KEY_VOL_DOWN: u32 = 0xe8;
563 const HID_USAGE_KEY_VOL_UP: u32 = 0xe9;
564
565 match keyboard_event.hid_usage {
566 HID_USAGE_KEY_F1..=HID_USAGE_KEY_F10 if modifiers.alt => {
567 let id = keyboard_event.hid_usage - HID_USAGE_KEY_F1;
568 self.set_active_terminal(id);
569 return Ok(true);
570 }
571 HID_USAGE_KEY_TAB if modifiers.alt => {
572 if modifiers.shift {
573 self.previous_active_terminal();
574 } else {
575 self.next_active_terminal();
576 }
577 return Ok(true);
578 }
579 HID_USAGE_KEY_VOL_UP if modifiers.alt => {
580 self.previous_active_terminal();
581 return Ok(true);
582 }
583 HID_USAGE_KEY_VOL_DOWN if modifiers.alt => {
584 self.next_active_terminal();
585 return Ok(true);
586 }
587 HID_USAGE_KEY_UP if modifiers.alt => {
588 self.scroll_active_terminal(Scroll::Lines(1));
589 return Ok(true);
590 }
591 HID_USAGE_KEY_DOWN if modifiers.alt => {
592 self.scroll_active_terminal(Scroll::Lines(-1));
593 return Ok(true);
594 }
595 HID_USAGE_KEY_PAGEUP if modifiers.shift => {
596 self.scroll_active_terminal(Scroll::PageUp);
597 return Ok(true);
598 }
599 HID_USAGE_KEY_PAGEDOWN if modifiers.shift => {
600 self.scroll_active_terminal(Scroll::PageDown);
601 return Ok(true);
602 }
603 HID_USAGE_KEY_HOME if modifiers.shift => {
604 self.scroll_active_terminal(Scroll::Top);
605 return Ok(true);
606 }
607 HID_USAGE_KEY_END if modifiers.shift => {
608 self.scroll_active_terminal(Scroll::Bottom);
609 return Ok(true);
610 }
611 _ => {}
612 }
613 }
614 Some(code_point) if modifiers.alt == true => {
615 const PLUS: u32 = 43;
616 const EQUAL: u32 = 61;
617 const MINUS: u32 = 45;
618
619 match code_point {
620 PLUS | EQUAL => {
621 let new_font_size =
622 (self.font_size + FONT_SIZE_INCREMENT).min(MAX_FONT_SIZE);
623 self.set_font_size(new_font_size);
624 return Ok(true);
625 }
626 MINUS => {
627 let new_font_size =
628 (self.font_size - FONT_SIZE_INCREMENT).max(MIN_FONT_SIZE);
629 self.set_font_size(new_font_size);
630 return Ok(true);
631 }
632 _ => {}
633 }
634 }
635 _ => {}
636 }
637 }
638 _ => {}
639 }
640
641 Ok(false)
642 }
643}
644
645impl ViewAssistant for VirtualConsoleViewAssistant {
646 fn resize(&mut self, _new_size: &Size) -> Result<(), Error> {
647 self.scene_details = None;
648 Ok(())
649 }
650
651 fn render(
652 &mut self,
653 render_context: &mut RenderContext,
654 ready_event: zx::Event,
655 context: &ViewAssistantContext,
656 ) -> Result<(), Error> {
657 let mut scene_details = self.scene_details.take().unwrap_or_else(|| {
658 let mut builder = SceneBuilder::new()
659 .background_color(self.color_scheme.back)
660 .enable_mouse_cursor(false)
661 .round_scene_corners(self.round_scene_corners)
662 .mutable(false);
663
664 let textgrid = {
665 let scale_factor = if let Some(info) = context.display_info.as_ref() {
666 if info.using_fallback_size {
669 1.0
670 } else {
671 const MM_PER_INCH: f32 = 25.4;
672
673 let dpi = context.size.height * MM_PER_INCH / info.vertical_size_mm as f32;
674
675 get_scale_factor(&self.dpi, dpi)
676 }
677 } else {
678 1.0
679 };
680 let cell_height = self.font_size * scale_factor;
681
682 self.resize_terminals(&context.size, cell_height);
683
684 let active_term =
685 self.terminals.get(&self.active_terminal_id).map(|(t, _)| t.clone_term());
686 let status = self.get_status();
687 let columns = active_term
688 .as_ref()
689 .map(|t| t.borrow().screen().size().1 as usize)
690 .unwrap_or(1);
691
692 let tab_width =
695 (columns as usize / (status.len() + 1)).clamp(MIN_TAB_WIDTH, MAX_TAB_WIDTH);
696
697 let cell_size = cell_size_from_cell_height(&self.font_set, cell_height);
698
699 let textgrid = builder.facet(Box::new(TextGridFacet::new(
701 self.font_set.clone(),
702 &cell_size,
703 self.color_scheme,
704 active_term,
705 status,
706 tab_width,
707 )));
708
709 self.cell_size = cell_size;
710 self.tab_width = tab_width;
711
712 Some(textgrid)
713 };
714
715 SceneDetails { scene: builder.build(), textgrid }
716 });
717
718 scene_details.scene.render(render_context, ready_event, context)?;
719 self.scene_details = Some(scene_details);
720
721 Ok(())
722 }
723
724 fn handle_input_event(
725 &mut self,
726 context: &mut ViewAssistantContext,
727 event: &input::Event,
728 ) -> Result<(), Error> {
729 if !self.owns_display {
730 return Ok(());
731 }
732 match &event.event_type {
733 input::EventType::Mouse(mouse_event) => {
734 self.handle_mouse_event(context, event, mouse_event)
735 }
736 input::EventType::Touch(touch_event) => {
737 self.handle_touch_event(context, event, touch_event)
738 }
739 input::EventType::Keyboard(keyboard_event) => {
740 self.handle_keyboard_event(context, event, keyboard_event)
741 }
742 input::EventType::ConsumerControl(consumer_control_event) => {
743 self.handle_consumer_control_event(context, event, consumer_control_event)
744 }
745 }
746 }
747
748 fn handle_consumer_control_event(
749 &mut self,
750 context: &mut ViewAssistantContext,
751 event: &input::Event,
752 consumer_control_event: &input::consumer_control::Event,
753 ) -> Result<(), Error> {
754 if !self.owns_display {
755 return Ok(());
756 }
757 self.handle_device_control_consumer_control_event(
758 context,
759 consumer_control_event,
760 event.event_time,
761 )?;
762 Ok(())
763 }
764
765 fn handle_keyboard_event(
766 &mut self,
767 context: &mut ViewAssistantContext,
768 _event: &input::Event,
769 keyboard_event: &input::keyboard::Event,
770 ) -> Result<(), Error> {
771 if !self.owns_display {
772 return Ok(());
773 }
774
775 if self.handle_device_control_keyboard_event(context, keyboard_event)? {
776 return Ok(());
777 }
778
779 if self.handle_control_keyboard_event(context, keyboard_event)? {
780 return Ok(());
781 }
782
783 if let Some((terminal, _)) = self.terminals.get_mut(&self.active_terminal_id) {
784 let app_cursor = terminal.mode();
786 if let Some(string) = get_input_sequence_for_key_event(keyboard_event, app_cursor) {
787 terminal
788 .write_all(string.as_bytes())
789 .unwrap_or_else(|e| println!("failed to write to terminal: {}", e));
790
791 self.scroll_active_terminal(Scroll::Bottom);
793 }
794 }
795
796 Ok(())
797 }
798
799 fn handle_pointer_event(
800 &mut self,
801 _context: &mut ViewAssistantContext,
802 _event: &input::Event,
803 pointer_event: &input::pointer::Event,
804 ) -> Result<(), Error> {
805 if !self.owns_display {
806 return Ok(());
807 }
808
809 match &pointer_event.phase {
810 input::pointer::Phase::Down(location) => {
811 self.active_pointer_id = Some(pointer_event.pointer_id.clone());
812 self.start_pointer_location = location.to_f32();
813 }
814 input::pointer::Phase::Moved(location) => {
815 if Some(pointer_event.pointer_id.clone()) == self.active_pointer_id {
816 let location_offset = location.to_f32() - self.start_pointer_location;
817
818 fn div_and_trunc(value: f32, divisor: f32) -> isize {
819 (value / divisor).trunc() as isize
820 }
821
822 let tab_width = self.tab_width as f32 * self.cell_size.width;
824 let mut terminal_offset = div_and_trunc(location_offset.x, tab_width);
825 while terminal_offset > 0 {
826 self.previous_active_terminal();
827 self.start_pointer_location.x += tab_width;
828 terminal_offset -= 1;
829 }
830 while terminal_offset < 0 {
831 self.next_active_terminal();
832 self.start_pointer_location.x -= tab_width;
833 terminal_offset += 1;
834 }
835
836 let cell_offset = div_and_trunc(location_offset.y, self.cell_size.height);
838 if cell_offset != 0 {
839 self.scroll_active_terminal(Scroll::Lines(cell_offset as isize));
840 self.start_pointer_location.y += cell_offset as f32 * self.cell_size.height;
841 }
842 }
843 }
844 input::pointer::Phase::Up => {
845 if Some(pointer_event.pointer_id.clone()) == self.active_pointer_id {
846 self.active_pointer_id = None;
847 }
848 }
849 _ => (),
850 }
851 Ok(())
852 }
853
854 fn handle_message(&mut self, message: carnelian::Message) {
855 if let Some(message) = message.downcast_ref::<ViewMessages>() {
856 match message {
857 ViewMessages::AddTerminalMessage(id, terminal, make_active) => {
858 let terminal = terminal.try_clone().expect("failed to clone terminal");
859 let has_output = true;
860 let display_offset = terminal.display_offset();
861 let at_top = display_offset == terminal.history_size();
862 let at_bottom = display_offset == 0;
863 self.terminals
864 .insert(*id, (terminal, TerminalStatus { has_output, at_top, at_bottom }));
865 self.scene_details = None;
868 self.app_sender.request_render(self.view_key);
869 if *make_active {
870 self.set_active_terminal(*id);
871 }
872 }
873 ViewMessages::RequestTerminalUpdateMessage(id) => {
874 if let Some((terminal, status)) = self.terminals.get_mut(id) {
875 let has_output = if *id == self.active_terminal_id {
876 self.app_sender.request_render(self.view_key);
877 false
878 } else {
879 true
880 };
881 let display_offset = terminal.display_offset();
882 let at_top = display_offset == terminal.history_size();
883 let at_bottom = display_offset == 0;
884 let new_status = TerminalStatus { has_output, at_top, at_bottom };
885 let old_status = mem::replace(status, new_status);
886 if new_status != old_status {
887 self.update_status();
888 }
889 }
890 }
891 }
892 }
893 }
894
895 fn ownership_changed(&mut self, owned: bool) -> Result<(), Error> {
896 self.handle_ownership_change(owned)
897 }
898}
899
900#[cfg(test)]
901mod tests {
902 use super::*;
903
904 #[test]
905 fn can_create_view() -> Result<(), Error> {
906 let _ = VirtualConsoleViewAssistant::new_for_test()?;
907 Ok(())
908 }
909
910 #[test]
911 fn power_button_press_handler_repetitive_presses() {
912 use carnelian::input::consumer_control::Event;
913
914 let mut handler = RepeatedButtonPressHandler::new(ConsumerControlButton::Power);
915 const EVENT_DOWN: Event = Event {
916 phase: carnelian::input::consumer_control::Phase::Down,
917 button: ConsumerControlButton::Power,
918 };
919 const EVENT_UP: Event = Event {
920 phase: carnelian::input::consumer_control::Phase::Up,
921 button: ConsumerControlButton::Power,
922 };
923
924 handler.handle_button_event(&EVENT_DOWN, 1_000_000_000);
925 handler.handle_button_event(&EVENT_UP, 1_100_000_000);
926 assert_eq!(handler.press_durations_ns, vec![100_000_000]);
927 assert_eq!(handler.down_times_ns, vec![1_000_000_000]);
928
929 handler.handle_button_event(&EVENT_DOWN, 1_200_000_000);
930 handler.handle_button_event(&EVENT_UP, 1_400_000_000);
931 assert_eq!(handler.press_durations_ns, vec![100_000_000, 200_000_000]);
932 assert_eq!(handler.down_times_ns, vec![1_000_000_000, 1_200_000_000]);
933 }
934
935 #[test]
936 fn power_button_press_handler_press_timeout() {
937 use carnelian::input::consumer_control::Event;
938
939 let mut handler = RepeatedButtonPressHandler::new(ConsumerControlButton::Power);
940 const EVENT_DOWN: Event = Event {
941 phase: carnelian::input::consumer_control::Phase::Down,
942 button: ConsumerControlButton::Power,
943 };
944 const EVENT_UP: Event = Event {
945 phase: carnelian::input::consumer_control::Phase::Up,
946 button: ConsumerControlButton::Power,
947 };
948
949 handler.handle_button_event(&EVENT_DOWN, 1_000_000_000);
950 handler.handle_button_event(&EVENT_UP, 1_100_000_000);
951 assert_eq!(handler.press_durations_ns, vec![100_000_000]);
952 assert_eq!(handler.down_times_ns, vec![1_000_000_000]);
953
954 handler.handle_button_event(&EVENT_DOWN, 5_100_000_000);
955 handler.handle_button_event(&EVENT_UP, 5_300_000_000);
956 assert_eq!(handler.press_durations_ns, vec![200_000_000]);
957 assert_eq!(handler.down_times_ns, vec![5_100_000_000]);
958 }
959
960 #[test]
961 fn power_button_press_handler_non_power_key_ignored() {
962 use carnelian::input::consumer_control::Event;
963
964 let mut handler = RepeatedButtonPressHandler::new(ConsumerControlButton::Power);
965 const POWER_EVENT_DOWN: Event = Event {
966 phase: carnelian::input::consumer_control::Phase::Down,
967 button: ConsumerControlButton::Power,
968 };
969 const POWER_EVENT_UP: Event = Event {
970 phase: carnelian::input::consumer_control::Phase::Up,
971 button: ConsumerControlButton::Power,
972 };
973 const FUNCTION_EVENT_DOWN: Event = Event {
974 phase: carnelian::input::consumer_control::Phase::Down,
975 button: ConsumerControlButton::Function,
976 };
977 const FUNCTION_EVENT_UP: Event = Event {
978 phase: carnelian::input::consumer_control::Phase::Up,
979 button: ConsumerControlButton::Function,
980 };
981
982 handler.handle_button_event(&POWER_EVENT_DOWN, 1_000_000_000);
983 handler.handle_button_event(&POWER_EVENT_UP, 1_100_000_000);
984 assert_eq!(handler.press_durations_ns, vec![100_000_000]);
985 assert_eq!(handler.down_times_ns, vec![1_000_000_000]);
986
987 handler.handle_button_event(&FUNCTION_EVENT_DOWN, 1_200_000_000);
988 handler.handle_button_event(&FUNCTION_EVENT_UP, 1_300_000_000);
989 assert_eq!(handler.press_durations_ns, vec![100_000_000]);
990 assert_eq!(handler.down_times_ns, vec![1_000_000_000]);
991 }
992
993 #[test]
994 fn test_ownership_change_and_input_gating() -> Result<(), Error> {
995 let mut assistant = VirtualConsoleViewAssistant::new_assistant_for_test()?;
996 assert!(assistant.owns_display());
997
998 let term0 = Terminal::new("term0".to_string(), ColorScheme::default(), 1024, None);
1000 let term1 = Terminal::new("term1".to_string(), ColorScheme::default(), 1024, None);
1001 let status = TerminalStatus { has_output: false, at_top: true, at_bottom: true };
1002 assistant.terminals.insert(0, (term0, status));
1003 assistant.terminals.insert(1, (term1, status));
1004 assert_eq!(assistant.active_terminal_id(), 0);
1005
1006 assistant.ownership_changed(false)?;
1008 assert!(!assistant.owns_display());
1009
1010 let mut context = ViewAssistantContext::new_for_testing();
1011 let dummy_input_event = input::Event {
1012 event_time: 100,
1013 device_id: input::DeviceId("test-device".to_string()),
1014 event_type: input::EventType::Keyboard(input::keyboard::Event {
1015 phase: input::keyboard::Phase::Pressed,
1016 hid_usage: 0x2b, modifiers: input::Modifiers { alt: true, ..Default::default() },
1018 code_point: None,
1019 }),
1020 };
1021
1022 let key_event = input::keyboard::Event {
1025 phase: input::keyboard::Phase::Pressed,
1026 hid_usage: 0x2b, modifiers: input::Modifiers { alt: true, ..Default::default() },
1028 code_point: None,
1029 };
1030 assistant.handle_keyboard_event(&mut context, &dummy_input_event, &key_event)?;
1031 assert_eq!(assistant.active_terminal_id(), 0);
1032
1033 assistant.handle_input_event(&mut context, &dummy_input_event)?;
1035 assert_eq!(assistant.active_terminal_id(), 0);
1036
1037 let pointer_down_event = input::pointer::Event {
1039 phase: input::pointer::Phase::Down(carnelian::IntPoint::new(10, 10)),
1040 pointer_id: input::pointer::PointerId::Mouse(input::DeviceId(
1041 "test-device".to_string(),
1042 )),
1043 };
1044 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_down_event)?;
1045 assert_eq!(assistant.active_pointer_id(), None);
1046
1047 assistant.ownership_changed(true)?;
1049 assert!(assistant.owns_display());
1050
1051 assistant.handle_keyboard_event(&mut context, &dummy_input_event, &key_event)?;
1053 assert_eq!(assistant.active_terminal_id(), 1);
1054
1055 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_down_event)?;
1057 assert_eq!(
1058 assistant.active_pointer_id(),
1059 Some(input::pointer::PointerId::Mouse(input::DeviceId("test-device".to_string())))
1060 );
1061
1062 assistant.ownership_changed(false)?;
1064 assert!(!assistant.owns_display());
1065 assert_eq!(assistant.active_pointer_id(), None);
1066
1067 Ok(())
1068 }
1069
1070 #[test]
1071 fn test_terminal_scrollback_gating() -> Result<(), Error> {
1072 let mut assistant = VirtualConsoleViewAssistant::new_assistant_for_test()?;
1073 let term = Terminal::new("term".to_string(), ColorScheme::default(), 1024, None);
1074 let status = TerminalStatus { has_output: false, at_top: true, at_bottom: true };
1075 assistant.terminals.insert(0, (term, status));
1076
1077 if let Some((terminal, _)) = assistant.terminals.get_mut(&0) {
1079 let term = terminal.clone_term();
1080 let mut parser = term.borrow_mut();
1081 for i in 0..50 {
1082 parser.process(format!("line {}\r\n", i).as_bytes());
1083 }
1084 }
1085 assistant.scroll_active_terminal(Scroll::Bottom);
1086 let offset_at_bottom = assistant.terminals.get(&0).unwrap().0.display_offset();
1087 assert_eq!(offset_at_bottom, 0);
1088
1089 let mut context = ViewAssistantContext::new_for_testing();
1090 let dummy_input_event = input::Event {
1091 event_time: 100,
1092 device_id: input::DeviceId("test-device".to_string()),
1093 event_type: input::EventType::Keyboard(input::keyboard::Event {
1094 phase: input::keyboard::Phase::Pressed,
1095 hid_usage: 0x4b, modifiers: input::Modifiers { shift: true, ..Default::default() },
1097 code_point: None,
1098 }),
1099 };
1100
1101 assistant.ownership_changed(false)?;
1103 let page_up_event = input::keyboard::Event {
1104 phase: input::keyboard::Phase::Pressed,
1105 hid_usage: 0x4b, modifiers: input::Modifiers { shift: true, ..Default::default() },
1107 code_point: None,
1108 };
1109 assistant.handle_keyboard_event(&mut context, &dummy_input_event, &page_up_event)?;
1110 assert_eq!(assistant.terminals.get(&0).unwrap().0.display_offset(), 0);
1111
1112 assistant.ownership_changed(true)?;
1114 assistant.handle_keyboard_event(&mut context, &dummy_input_event, &page_up_event)?;
1115 assert!(assistant.terminals.get(&0).unwrap().0.display_offset() > 0);
1116
1117 let char_event = input::keyboard::Event {
1119 phase: input::keyboard::Phase::Pressed,
1120 hid_usage: 0x04, modifiers: Default::default(),
1122 code_point: Some(97),
1123 };
1124 assistant.handle_keyboard_event(&mut context, &dummy_input_event, &char_event)?;
1125 assert_eq!(assistant.terminals.get(&0).unwrap().0.display_offset(), 0);
1126
1127 let pointer_down = input::pointer::Event {
1129 phase: input::pointer::Phase::Down(carnelian::IntPoint::new(10, 10)),
1130 pointer_id: input::pointer::PointerId::Mouse(input::DeviceId(
1131 "test-device".to_string(),
1132 )),
1133 };
1134 let pointer_move = input::pointer::Event {
1135 phase: input::pointer::Phase::Moved(carnelian::IntPoint::new(10, 50)),
1136 pointer_id: input::pointer::PointerId::Mouse(input::DeviceId(
1137 "test-device".to_string(),
1138 )),
1139 };
1140 let pointer_up = input::pointer::Event {
1141 phase: input::pointer::Phase::Up,
1142 pointer_id: input::pointer::PointerId::Mouse(input::DeviceId(
1143 "test-device".to_string(),
1144 )),
1145 };
1146
1147 assistant.ownership_changed(false)?;
1149 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_down)?;
1150 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_move)?;
1151 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_up)?;
1152 assert_eq!(assistant.terminals.get(&0).unwrap().0.display_offset(), 0);
1153
1154 assistant.ownership_changed(true)?;
1156 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_down)?;
1157 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_move)?;
1158 assistant.handle_pointer_event(&mut context, &dummy_input_event, &pointer_up)?;
1159 assert!(assistant.terminals.get(&0).unwrap().0.display_offset() > 0);
1160
1161 Ok(())
1162 }
1163}