Skip to main content

radio_cli/
tui.rs

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