Skip to main content

radio_cli/
tui.rs

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