Skip to main content

radio_cli/
tui.rs

1mod artwork;
2mod capabilities;
3mod command;
4mod display;
5mod help;
6mod output;
7mod render;
8mod state;
9mod styles;
10#[cfg(test)]
11mod tests;
12mod text;
13mod worker;
14
15use crate::{config::Config, engine::Engine};
16use anyhow::{Result, bail};
17use crossterm::{
18    event::{
19        self, DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
20        Event, KeyEventKind,
21    },
22    execute,
23    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
24};
25use ratatui::{Terminal, backend::CrosstermBackend};
26use state::App;
27use std::{
28    io::{self, IsTerminal},
29    sync::{
30        Arc, Mutex,
31        atomic::{AtomicBool, Ordering},
32    },
33    thread,
34    time::{Duration, Instant},
35};
36use worker::View;
37
38/// Pointer motion, drags and releases never change visible state, so they must not repaint.
39fn mouse_redraws(kind: event::MouseEventKind) -> bool {
40    use event::MouseEventKind::{Drag, Moved, Up};
41    !matches!(kind, Moved | Drag(_) | Up(_))
42}
43
44struct Screen;
45impl Screen {
46    fn enter(mouse: bool) -> Result<Self> {
47        enable_raw_mode()?;
48        let guard = Self;
49        execute!(io::stdout(), EnterAlternateScreen)?;
50        if mouse {
51            execute!(io::stdout(), EnableMouseCapture)?;
52        }
53        Ok(guard)
54    }
55}
56impl Drop for Screen {
57    fn drop(&mut self) {
58        let _ = disable_raw_mode();
59        let _ = execute!(
60            io::stdout(),
61            DisableBracketedPaste,
62            DisableMouseCapture,
63            LeaveAlternateScreen
64        );
65    }
66}
67
68pub fn run(config: Config, stop: Arc<AtomicBool>) -> Result<()> {
69    if !io::stdin().is_terminal() || !io::stdout().is_terminal() {
70        bail!(crate::t!("tui_requires_terminal"));
71    }
72    let no_color = std::env::var_os("NO_COLOR").is_some_and(|s| !s.is_empty());
73    let theme = config.settings.theme.effective(no_color);
74    let mouse = config.settings.mouse;
75    let jump_binding = config.settings.keybindings.jump_to_playing.clone();
76    let artwork_config = config.clone();
77    let history_path = config.data_dir.join("command-history.json");
78    if theme == crate::config::Theme::Mono {
79        crossterm::style::force_color_output(false);
80    }
81    let engine = Engine::new(config, stop.clone())?;
82    let mut app = App::restore(&engine.store, engine.config.settings.resume)?;
83    let view = Arc::new(Mutex::new(View::new(engine.status.clone())));
84    let (sender, receiver) = command::channel(16);
85    let worker_view = view.clone();
86    let worker_stop = stop.clone();
87    let initial_filter = app.filter.clone();
88    let handle = thread::spawn(move || {
89        worker::run(engine, receiver, worker_view, worker_stop, initial_filter)
90    });
91    let result = (|| -> Result<()> {
92        let _screen = Screen::enter(mouse)?;
93        let mut pending = std::collections::VecDeque::new();
94        let mut artwork = artwork::Controller::new(artwork_config, theme, &mut pending);
95        // Enabled only after startup probing, which reads raw terminal replies itself.
96        execute!(io::stdout(), EnableBracketedPaste)?;
97        let writer = output::TerminalWriter::new(io::stdout(), theme == crate::config::Theme::Mono);
98        let mut terminal = Terminal::new(CrosstermBackend::new(writer))?;
99        execute!(
100            io::stdout(),
101            crossterm::terminal::Clear(crossterm::terminal::ClearType::All)
102        )?;
103        app.mouse_enabled = mouse;
104        app.jump_binding = jump_binding;
105        if let Err(error) = app.editor.load_history(history_path) {
106            app.message = crate::t!("history_load_failed", "detail" => error);
107        }
108        app.theme = theme;
109        let mut revision = 0;
110        let mut immediate_revision = 0;
111        let mut last_draw = Instant::now();
112        let mut dirty = true;
113        while !stop.load(Ordering::Relaxed) && !app.quit {
114            let size = terminal.size()?;
115            app.update_size(size.width, size.height);
116            let snapshot = view.lock().unwrap().snapshot();
117            app.reconcile(&snapshot);
118            dirty |= app.expire_message(Instant::now());
119            if let Some(artwork) = &mut artwork {
120                let size = terminal.size()?;
121                let screen = ratatui::layout::Rect::new(0, 0, size.width, size.height);
122                view.lock().unwrap().artwork_station = artwork.demand(&app, &snapshot, screen);
123                dirty |= artwork.update(&mut app, &snapshot, screen);
124            }
125            app.request_selected_backups(&snapshot, &sender);
126            app.request_facets(&sender);
127            if dirty
128                || revision != snapshot.revision
129                    && (immediate_revision != snapshot.immediate_revision
130                        || last_draw.elapsed() >= Duration::from_secs(1))
131            {
132                terminal.draw(|frame| render::draw(frame, &mut app, &snapshot))?;
133                revision = snapshot.revision;
134                immediate_revision = snapshot.immediate_revision;
135                last_draw = Instant::now();
136                dirty = false;
137            }
138            if !app.too_small && app.search_due.is_some_and(|due| Instant::now() >= due) {
139                app.flush_search(&sender);
140                dirty = true;
141            }
142            if handle.is_finished() {
143                break;
144            }
145            let event = if let Some(event) = pending.pop_front() {
146                event
147            } else {
148                if !event::poll(Duration::from_millis(100))? {
149                    continue;
150                }
151                event::read()?
152            };
153            match event {
154                Event::Resize(width, height) => {
155                    app.update_size(width, height);
156                    dirty = true;
157                }
158                Event::Key(key) if key.kind != KeyEventKind::Release => {
159                    let size = terminal.size()?;
160                    app.update_size(size.width, size.height);
161                    let old_mouse = app.mouse_enabled;
162                    app.key(key, &snapshot, &sender);
163                    if app.mouse_enabled != old_mouse {
164                        if app.mouse_enabled {
165                            execute!(io::stdout(), EnableMouseCapture)?;
166                        } else {
167                            execute!(io::stdout(), DisableMouseCapture)?;
168                        }
169                    }
170                    if let Some(value) = app.clipboard.take() {
171                        use std::io::Write;
172                        io::stdout().write_all(&output::clipboard_sequence(&value))?;
173                        io::stdout().flush()?;
174                    }
175                    dirty = true;
176                }
177                Event::Paste(text) => {
178                    app.paste(&text);
179                    dirty = true;
180                }
181                Event::Mouse(mouse) => {
182                    app.mouse(mouse, &snapshot, &sender);
183                    dirty |= mouse_redraws(mouse.kind);
184                }
185                _ => {}
186            }
187        }
188        drop(artwork);
189        stop.store(true, Ordering::Relaxed);
190        terminal.draw(|frame| {
191            let hint = if matches!(
192                view.lock().unwrap().status.recording_state,
193                crate::engine::RecordingState::Probing
194                    | crate::engine::RecordingState::Recording
195                    | crate::engine::RecordingState::Finalizing
196            ) {
197                crate::t!("exiting_recording")
198            } else {
199                crate::t!("exiting_cleanup")
200            };
201            frame.render_widget(ratatui::widgets::Paragraph::new(hint), frame.area());
202        })?;
203        // Keep the alternate screen and hint until bounded media cleanup ends.
204        while !handle.is_finished() {
205            thread::sleep(Duration::from_millis(20));
206        }
207        Ok(())
208    })();
209    stop.store(true, Ordering::Relaxed);
210    drop(sender);
211    let worker_result = handle
212        .join()
213        .map_err(|_| anyhow::anyhow!(crate::t!("ui_worker_failed")))?;
214    result?;
215    worker_result
216}