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