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
40fn 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 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 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}