1use crate::{PagerState, error::MinusError, minus_core::utils::term};
2mod deferred;
3use crossterm::{
4 cursor,
5 event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
6 terminal::{Clear, ClearType},
7};
8pub use deferred::SourceViewRenderer;
9use std::io::Write;
10use std::time::Duration;
11
12#[derive(Clone, Debug, Eq, PartialEq)]
14pub struct LineNavigation {
15 pub(crate) toc: Vec<crate::TocEntry>,
16 display_source_lines: Vec<Option<usize>>,
18 source_view: SourceView,
19}
20
21#[derive(Clone, Debug, Eq, PartialEq)]
22enum SourceView {
23 Current,
24 Deferred(deferred::DeferredSource),
25 Alternate {
26 text: String,
27 source_lines: Vec<Option<usize>>,
28 },
29}
30
31pub struct LineNavigationSession {
32 original_upper_mark: usize,
33 original_left_mark: usize,
34 target: Option<usize>,
35 prompt_origin: Option<usize>,
36}
37
38impl LineNavigation {
39 pub fn prepare_source_view(&mut self) -> Result<(), crate::PromptError> {
45 if let SourceView::Deferred(source) = &self.source_view {
46 let (text, source_lines) = (source.0)().map_err(crate::PromptError::Layout)?;
47 self.source_view = SourceView::Alternate { text, source_lines };
48 }
49 Ok(())
50 }
51
52 #[must_use]
54 pub fn deferred(
55 display_source_lines: Vec<Option<usize>>,
56 renderer: SourceViewRenderer,
57 ) -> Self {
58 Self {
59 toc: Vec::new(),
60 display_source_lines,
61 source_view: SourceView::Deferred(deferred::DeferredSource(renderer)),
62 }
63 }
64
65 #[must_use]
70 pub fn new(
71 source_text: impl Into<String>,
72 display_source_lines: Vec<Option<usize>>,
73 navigation_source_lines: Vec<Option<usize>>,
74 ) -> Self {
75 Self {
76 toc: Vec::new(),
77 display_source_lines,
78 source_view: SourceView::Alternate {
79 text: source_text.into(),
80 source_lines: navigation_source_lines,
81 },
82 }
83 }
84
85 #[must_use]
87 pub const fn from_current(source_lines: Vec<Option<usize>>) -> Self {
88 Self {
89 toc: Vec::new(),
90 display_source_lines: source_lines,
91 source_view: SourceView::Current,
92 }
93 }
94
95 #[must_use]
97 pub fn with_toc(mut self, entries: Vec<crate::TocEntry>) -> Self {
98 self.toc = entries;
99 self
100 }
101}
102
103#[derive(Clone, Copy)]
104pub enum LineInputResult {
105 Cancelled,
106 Confirmed(Option<usize>),
107}
108
109impl PagerState {
110 pub(crate) fn replace_mapped_text(
111 &mut self,
112 text: String,
113 navigation: Option<LineNavigation>,
114 ) -> Result<(), crate::PromptError> {
115 let navigation_view = self.line_navigation_session.is_some();
116 let anchor = self.source_line_map(navigation_view).and_then(|map| {
117 let index = self.lines_to_row_map.row_to_line(self.upper_mark)?;
118 (0..=index).rev().find_map(|i| {
119 Some((
120 map.get(i).copied().flatten()?,
121 self.upper_mark
122 .saturating_sub(*self.lines_to_row_map.get(i)?),
123 ))
124 })
125 });
126 self.line_navigation_session = None;
127 self.toc.reset_position();
128 self.line_navigation = navigation;
129 self.screen.orig_text = text;
130 self.screen.line_count = self.screen.orig_text.lines().count();
131 self.clear_selection();
132 self.left_mark = 0;
133 self.reformat_display()?;
134 if let Some((source, offset)) = anchor
135 && let Some(row) = self.row_for_source_line(source, false)
136 {
137 let next = (row + 1..self.screen.formatted_lines.len())
138 .find(|&i| {
139 self.source_line_at_row(i, false)
140 .is_some_and(|line| line != source)
141 })
142 .unwrap_or(self.screen.formatted_lines.len());
143 self.upper_mark = row.saturating_add(offset.min(next.saturating_sub(row + 1)));
144 }
145 self.upper_mark = self.upper_mark.min(self.max_upper_mark());
146 self.format_prompt()
147 }
148
149 #[must_use]
151 pub(crate) const fn line_navigation_available(&self) -> bool {
152 if self.line_navigation.is_none() {
153 return false;
154 }
155 match &self.line_navigation_session {
156 Some(session) => session.prompt_origin.is_none(),
157 None => true,
158 }
159 }
160
161 #[must_use]
163 pub(crate) const fn line_navigation_is_active(&self) -> bool {
164 match &self.line_navigation_session {
165 Some(session) => session.prompt_origin.is_none() && session.target.is_some(),
166 None => false,
167 }
168 }
169
170 #[must_use]
171 pub(crate) const fn line_navigation_position(&self) -> Option<usize> {
172 match &self.line_navigation_session {
173 Some(session) if session.prompt_origin.is_none() => session.target,
174 _ => None,
175 }
176 }
177
178 pub(crate) fn begin_line_navigation(&mut self) -> Result<bool, crate::PromptError> {
179 if !self.line_navigation_available() {
180 return Ok(false);
181 }
182
183 if self.line_navigation_session.is_none() {
184 let navigation = self
185 .line_navigation
186 .as_mut()
187 .expect("available line navigation requires configured content");
188 navigation.prepare_source_view()?;
189 let original_upper_mark = self.upper_mark;
190 let original_left_mark = self.left_mark;
191 let uses_alternate_view = self.line_navigation.as_ref().is_some_and(|navigation| {
192 matches!(navigation.source_view, SourceView::Alternate { .. })
193 });
194 let visible_source_line = self.source_line_at_row(self.upper_mark, false);
195 if uses_alternate_view {
196 self.left_mark = 0;
197 self.swap_line_navigation_text();
198 self.reformat_display()?;
199 self.upper_mark = visible_source_line
200 .and_then(|line| self.row_for_source_line(line, true))
201 .unwrap_or(self.upper_mark)
202 .min(self.max_upper_mark());
203 }
204 self.line_navigation_session = Some(LineNavigationSession {
205 original_upper_mark,
206 original_left_mark,
207 target: None,
208 prompt_origin: None,
209 });
210 }
211
212 if let Some(session) = self.line_navigation_session.as_mut() {
213 session.prompt_origin = Some(self.upper_mark);
214 }
215 self.selection = None;
216 self.selection_anchor = None;
217 Ok(true)
218 }
219
220 pub(crate) fn configure_line_navigation(
221 &mut self,
222 navigation: Option<LineNavigation>,
223 ) -> Result<(), crate::PromptError> {
224 self.exit_line_navigation()?;
225 self.line_navigation = navigation;
226 Ok(())
227 }
228
229 pub(crate) fn finish_line_navigation(
230 &mut self,
231 source_line: Option<usize>,
232 ) -> Result<bool, crate::PromptError> {
233 let Some(prompt_upper_mark) = self
234 .line_navigation_session
235 .as_mut()
236 .and_then(|session| session.prompt_origin.take())
237 else {
238 return Ok(false);
239 };
240
241 if let Some(source_line) = source_line
242 && let Some(target_row) = self.row_for_source_line(source_line, true)
243 {
244 self.upper_mark = target_row;
245 if let Some(session) = self.line_navigation_session.as_mut() {
246 session.target = Some(source_line);
247 }
248 return Ok(true);
249 }
250
251 if self
252 .line_navigation_session
253 .as_ref()
254 .is_some_and(|session| session.target.is_some())
255 {
256 self.upper_mark = prompt_upper_mark;
257 } else {
258 self.exit_line_navigation()?;
259 }
260 Ok(false)
261 }
262
263 pub(crate) fn exit_line_navigation(&mut self) -> Result<bool, crate::PromptError> {
264 let Some(session) = self.line_navigation_session.take() else {
265 return Ok(false);
266 };
267 let visible_source_line = self.source_line_at_row(self.upper_mark, true);
268
269 let uses_alternate_view = self.line_navigation.as_ref().is_some_and(|navigation| {
270 matches!(navigation.source_view, SourceView::Alternate { .. })
271 });
272 if uses_alternate_view {
273 self.swap_line_navigation_text();
274 self.left_mark = session.original_left_mark;
275 self.reformat_display()?;
276 }
277
278 let source_line = visible_source_line.or(session.target);
279 if let Some(target_row) = source_line.and_then(|line| self.row_for_source_line(line, false))
280 {
281 self.upper_mark = target_row;
282 } else {
283 self.upper_mark = session.original_upper_mark.min(self.max_upper_mark());
284 }
285 Ok(true)
286 }
287
288 pub(crate) fn source_line_is_highlighted(&self, absolute_row: usize) -> bool {
289 if !self.line_navigation_is_active() {
290 return false;
291 }
292 self.source_line_at_row(absolute_row, true) == self.line_navigation_position()
293 }
294
295 fn swap_line_navigation_text(&mut self) {
296 let navigation = self
297 .line_navigation
298 .as_mut()
299 .expect("line navigation session requires configured content");
300 let SourceView::Alternate { text, .. } = &mut navigation.source_view else {
301 unreachable!("swapped line navigation session requires alternate content");
302 };
303 std::mem::swap(&mut self.screen.orig_text, text);
304 self.screen.line_count = self.screen.orig_text.lines().count();
305 }
306
307 fn source_line_at_row(&self, row: usize, navigation_view: bool) -> Option<usize> {
308 let line_map = self.source_line_map(navigation_view)?;
309 let line_index = self.lines_to_row_map.row_to_line(row)?;
310 line_map.get(line_index).copied().flatten()
311 }
312
313 pub(crate) fn row_for_source_line(
314 &self,
315 source_line: usize,
316 navigation_view: bool,
317 ) -> Option<usize> {
318 let line_map = self.source_line_map(navigation_view)?;
319 let line_index = line_map
320 .iter()
321 .position(|line| *line == Some(source_line))?;
322 self.lines_to_row_map.get(line_index).copied()
323 }
324
325 fn source_line_map(&self, navigation_view: bool) -> Option<&[Option<usize>]> {
326 let navigation = self.line_navigation.as_ref()?;
327 match (&navigation.source_view, navigation_view) {
328 (SourceView::Alternate { source_lines, .. }, true) => Some(source_lines),
329 _ => Some(&navigation.display_source_lines),
330 }
331 }
332}
333
334pub fn fetch_line_number(
335 out: &mut impl Write,
336 pager: &PagerState,
337) -> Result<LineInputResult, MinusError> {
338 let mut input = String::new();
339 draw_input(out, pager, &input)?;
340
341 let result = loop {
342 if !event::poll(Duration::from_millis(100))
343 .map_err(|error| MinusError::HandleEvent(error.into()))?
344 {
345 continue;
346 }
347 let event = event::read().map_err(|error| MinusError::HandleEvent(error.into()))?;
348 let Event::Key(key) = event else {
349 continue;
350 };
351 if key.kind != KeyEventKind::Press || key.modifiers != KeyModifiers::NONE {
352 continue;
353 }
354 match key.code {
355 KeyCode::Esc => break LineInputResult::Cancelled,
356 KeyCode::Enter => {
357 let line = input.parse::<usize>().ok().filter(|line| *line > 0);
358 break LineInputResult::Confirmed(line);
359 }
360 KeyCode::Backspace => {
361 input.pop();
362 draw_input(out, pager, &input)?;
363 }
364 KeyCode::Char(character) if character.is_ascii_digit() => {
365 input.push(character);
366 draw_input(out, pager, &input)?;
367 }
368 _ => {}
369 }
370 };
371
372 let row = prompt_row(pager)?;
373 term::move_cursor(out, 0, row, false)?;
374 write!(out, "{}{}", Clear(ClearType::CurrentLine), cursor::Hide)?;
375 out.flush()?;
376 Ok(result)
377}
378
379fn draw_input(out: &mut impl Write, pager: &PagerState, input: &str) -> Result<(), MinusError> {
380 let row = prompt_row(pager)?;
381 let column = input
382 .chars()
383 .count()
384 .saturating_add(1)
385 .try_into()
386 .unwrap_or(u16::MAX);
387 term::move_cursor(out, 0, row, false)?;
388 write!(
389 out,
390 "{}:{input}{}",
391 Clear(ClearType::CurrentLine),
392 cursor::Show
393 )?;
394 term::move_cursor(out, column, row, false)?;
395 out.flush().map_err(MinusError::Draw)
396}
397
398fn prompt_row(pager: &PagerState) -> Result<u16, MinusError> {
399 pager
400 .prompt_row()
401 .try_into()
402 .map_err(|_| MinusError::Conversion)
403}
404
405#[cfg(test)]
406mod tests;