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