Skip to main content

virtual_console_lib/
view.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use 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
61// Constraints on status bar tabs.
62const MIN_TAB_WIDTH: usize = 16;
63const MAX_TAB_WIDTH: usize = 32;
64
65// Status bar colors.
66const 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
70// Amount of change to font size when zooming.
71const FONT_SIZE_INCREMENT: f32 = 4.0;
72
73// Maximum terminal size in cells. We support up to 4 layers per cell.
74const 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
88// Handles and records repeated button presses.
89//
90// Repeated button presses are defined as one or more button presses where
91// the interval between two consecutive events doesn't exceed 2 seconds.
92struct RepeatedButtonPressHandler {
93    // Durations of each button press for repeated button presses.
94    //
95    // `press_durations_ns` and `down_times_ns` are guaranteed to be of the
96    // same size.
97    press_durations_ns: Vec<u64>,
98
99    // Timestamps of the press-down event for each button press for repeated
100    // button presses.
101    down_times_ns: Vec<u64>,
102
103    button: ConsumerControlButton,
104
105    // Timestamp of the most recent button down event waiting for
106    // release.
107    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    // Returns true iff the event can be handled by this handler.
121    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        // event.phase == carnelian::input::consumer_control::Phase::Up
136        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        // down_time_ns is guaranteed to be >= last_down_time_ns.
157        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    // Resize all terminals for 'new_size'.
310    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        // Clamp width to respect `MAX_CELLS`.
315        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        // PTY window size (in character cells).
347        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    // This returns a vector with the status for each terminal. The return value
365    // is suitable for passing to the TextGridFacet.
366    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                    // Provides a CTRL-ALT-DEL reboot sequence.
531                    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                    // Use 1.0 scale factor when fallback sizes are used as opposed
667                    // to actual values reported by the display.
668                    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                // Determine the status bar tab width based on the current number
693                // of terminals.
694                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                // Add the text grid to the scene.
700                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            // Get input sequence and write it to the active terminal.
785            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                // Scroll to bottom on input.
792                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                    // Movement along X-axis changes active terminal.
823                    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                    // Movement along Y-axis scrolls active terminal.
837                    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                    // Rebuild the scene after a terminal is added. This should
866                    // be fine as it is rare that a terminal is added.
867                    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        // Add two terminals so we can test terminal switching.
999        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        // When owns_display is changed to false.
1007        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, // Tab
1017                modifiers: input::Modifiers { alt: true, ..Default::default() },
1018                code_point: None,
1019            }),
1020        };
1021
1022        // Key event: Alt-Tab should switch terminal when owns_display is true,
1023        // but must be ignored when owns_display is false.
1024        let key_event = input::keyboard::Event {
1025            phase: input::keyboard::Phase::Pressed,
1026            hid_usage: 0x2b, // Tab
1027            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        // handle_input_event should also be ignored when owns_display is false.
1034        assistant.handle_input_event(&mut context, &dummy_input_event)?;
1035        assert_eq!(assistant.active_terminal_id(), 0);
1036
1037        // Pointer event: Down should be ignored when owns_display is false.
1038        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        // When ownership is regained (owns_display = true).
1048        assistant.ownership_changed(true)?;
1049        assert!(assistant.owns_display());
1050
1051        // Alt-Tab should now switch active terminal.
1052        assistant.handle_keyboard_event(&mut context, &dummy_input_event, &key_event)?;
1053        assert_eq!(assistant.active_terminal_id(), 1);
1054
1055        // Pointer down should now be tracked.
1056        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        // Ownership lost again should reset in-flight pointer state.
1063        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        // Process lines in active terminal to create scrollback history.
1078        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, // PageUp
1096                modifiers: input::Modifiers { shift: true, ..Default::default() },
1097                code_point: None,
1098            }),
1099        };
1100
1101        // When owns_display is false, Shift-PageUp scrollback must be ignored.
1102        assistant.ownership_changed(false)?;
1103        let page_up_event = input::keyboard::Event {
1104            phase: input::keyboard::Phase::Pressed,
1105            hid_usage: 0x4b, // PageUp
1106            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        // When owns_display is true, Shift-PageUp scrollback must be processed.
1113        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        // When a character key is pressed while owns_display is true, it scrolls to bottom.
1118        let char_event = input::keyboard::Event {
1119            phase: input::keyboard::Phase::Pressed,
1120            hid_usage: 0x04, // 'a'
1121            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        // Test pointer scrolling when owns_display is false vs true.
1128        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        // When owns_display is false, pointer scroll must be ignored.
1148        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        // When owns_display is true, pointer scroll must be processed.
1155        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}