From 570bc9f32d7ef0bf741fab44d15f7cd54a1f3fc1 Mon Sep 17 00:00:00 2001 From: mo8it Date: Sat, 24 Aug 2024 00:14:12 +0200 Subject: Start list without Ratatui --- src/list.rs | 150 ++++++++++++++++++++++++++++++++---------------------------- 1 file changed, 79 insertions(+), 71 deletions(-) (limited to 'src/list.rs') diff --git a/src/list.rs b/src/list.rs index 6ff6959..754c5e2 100644 --- a/src/list.rs +++ b/src/list.rs @@ -1,95 +1,101 @@ use anyhow::{Context, Result}; -use ratatui::{ - backend::CrosstermBackend, - crossterm::{ - event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind}, - terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}, - QueueableCommand, +use crossterm::{ + cursor, + event::{ + self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind, MouseEventKind, }, - Terminal, + terminal::{ + disable_raw_mode, enable_raw_mode, DisableLineWrap, EnableLineWrap, EnterAlternateScreen, + LeaveAlternateScreen, + }, + QueueableCommand, }; use std::io::{self, StdoutLock, Write}; use crate::app_state::AppState; -use self::state::{Filter, UiState}; +use self::state::{Filter, ListState}; mod state; fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> { - let mut terminal = Terminal::new(CrosstermBackend::new(stdout))?; - terminal.clear()?; - - let mut ui_state = UiState::new(app_state); - - 'outer: loop { - terminal.try_draw(|frame| ui_state.draw(frame).map_err(io::Error::other))?; - - let key = loop { - match event::read().context("Failed to read terminal event")? { - Event::Key(key) => match key.kind { - KeyEventKind::Press | KeyEventKind::Repeat => break key, - KeyEventKind::Release => (), - }, - // Redraw - Event::Resize(_, _) => continue 'outer, - // Ignore - Event::FocusGained | Event::FocusLost | Event::Mouse(_) | Event::Paste(_) => (), + let mut list_state = ListState::new(app_state, stdout)?; + + loop { + match event::read().context("Failed to read terminal event")? { + Event::Key(key) => { + match key.kind { + KeyEventKind::Release => continue, + KeyEventKind::Press | KeyEventKind::Repeat => (), + } + + list_state.message.clear(); + + match key.code { + KeyCode::Char('q') => return Ok(()), + KeyCode::Down | KeyCode::Char('j') => list_state.select_next(), + KeyCode::Up | KeyCode::Char('k') => list_state.select_previous(), + KeyCode::Home | KeyCode::Char('g') => list_state.select_first(), + KeyCode::End | KeyCode::Char('G') => list_state.select_last(), + KeyCode::Char('d') => { + let message = if list_state.filter() == Filter::Done { + list_state.set_filter(Filter::None); + "Disabled filter DONE" + } else { + list_state.set_filter(Filter::Done); + "Enabled filter DONE │ Press d again to disable the filter" + }; + + list_state.message.push_str(message); + } + KeyCode::Char('p') => { + let message = if list_state.filter() == Filter::Pending { + list_state.set_filter(Filter::None); + "Disabled filter PENDING" + } else { + list_state.set_filter(Filter::Pending); + "Enabled filter PENDING │ Press p again to disable the filter" + }; + + list_state.message.push_str(message); + } + KeyCode::Char('r') => { + list_state.reset_selected()?; + } + KeyCode::Char('c') => { + return list_state.selected_to_current_exercise(); + } + // Redraw to remove the message. + KeyCode::Esc => (), + _ => continue, + } + + list_state.redraw(stdout)?; } - }; - - ui_state.message.clear(); - - match key.code { - KeyCode::Char('q') => break, - KeyCode::Down | KeyCode::Char('j') => ui_state.select_next(), - KeyCode::Up | KeyCode::Char('k') => ui_state.select_previous(), - KeyCode::Home | KeyCode::Char('g') => ui_state.select_first(), - KeyCode::End | KeyCode::Char('G') => ui_state.select_last(), - KeyCode::Char('d') => { - let message = if ui_state.filter == Filter::Done { - ui_state.filter = Filter::None; - "Disabled filter DONE" - } else { - ui_state.filter = Filter::Done; - "Enabled filter DONE │ Press d again to disable the filter" - }; - - ui_state = ui_state.with_updated_rows(); - ui_state.message.push_str(message); + Event::Mouse(event) => { + match event.kind { + MouseEventKind::ScrollDown => list_state.select_next(), + MouseEventKind::ScrollUp => list_state.select_previous(), + _ => continue, + } + + list_state.redraw(stdout)?; } - KeyCode::Char('p') => { - let message = if ui_state.filter == Filter::Pending { - ui_state.filter = Filter::None; - "Disabled filter PENDING" - } else { - ui_state.filter = Filter::Pending; - "Enabled filter PENDING │ Press p again to disable the filter" - }; - - ui_state = ui_state.with_updated_rows(); - ui_state.message.push_str(message); - } - KeyCode::Char('r') => { - ui_state = ui_state.with_reset_selected()?; - } - KeyCode::Char('c') => { - ui_state.selected_to_current_exercise()?; - break; - } - _ => (), + // Redraw + Event::Resize(_, _) => list_state.redraw(stdout)?, + // Ignore + Event::FocusGained | Event::FocusLost => (), } } - - Ok(()) } pub fn list(app_state: &mut AppState) -> Result<()> { let mut stdout = io::stdout().lock(); stdout .queue(EnterAlternateScreen)? - .queue(EnableMouseCapture)? - .flush()?; + .queue(cursor::Hide)? + .queue(DisableLineWrap)? + .queue(EnableMouseCapture)?; enable_raw_mode()?; let res = handle_list(app_state, &mut stdout); @@ -97,6 +103,8 @@ pub fn list(app_state: &mut AppState) -> Result<()> { // Restore the terminal even if we got an error. stdout .queue(LeaveAlternateScreen)? + .queue(cursor::Show)? + .queue(EnableLineWrap)? .queue(DisableMouseCapture)? .flush()?; disable_raw_mode()?; -- cgit v1.2.3 From 4e12725616abe1918d6a4f21b23288dfac237cc4 Mon Sep 17 00:00:00 2001 From: mo8it Date: Sat, 24 Aug 2024 00:23:45 +0200 Subject: Don't exit the list on "to current" if nothing is selected --- src/list.rs | 4 +++- src/list/state.rs | 20 +++++++++++--------- 2 files changed, 14 insertions(+), 10 deletions(-) (limited to 'src/list.rs') diff --git a/src/list.rs b/src/list.rs index 754c5e2..27a31d1 100644 --- a/src/list.rs +++ b/src/list.rs @@ -63,7 +63,9 @@ fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> list_state.reset_selected()?; } KeyCode::Char('c') => { - return list_state.selected_to_current_exercise(); + if list_state.selected_to_current_exercise()? { + return Ok(()); + } } // Redraw to remove the message. KeyCode::Esc => (), diff --git a/src/list/state.rs b/src/list/state.rs index cf147b4..645c768 100644 --- a/src/list/state.rs +++ b/src/list/state.rs @@ -250,25 +250,27 @@ impl<'a> ListState<'a> { Ok(()) } - pub fn selected_to_current_exercise(&mut self) -> Result<()> { + // Return `true` if there was something to select. + pub fn selected_to_current_exercise(&mut self) -> Result { let Some(selected) = self.selected else { - // TODO: Don't exit list - return Ok(()); + self.message.push_str("Nothing selected to continue at!"); + return Ok(false); }; - let ind = self + let (ind, _) = self .app_state .exercises() .iter() .enumerate() - .filter_map(|(ind, exercise)| match self.filter { - Filter::Done => exercise.done.then_some(ind), - Filter::Pending => (!exercise.done).then_some(ind), - Filter::None => Some(ind), + .filter(|(_, exercise)| match self.filter { + Filter::Done => exercise.done, + Filter::Pending => !exercise.done, + Filter::None => true, }) .nth(selected) .context("Invalid selection index")?; - self.app_state.set_current_exercise_ind(ind) + self.app_state.set_current_exercise_ind(ind)?; + Ok(true) } } -- cgit v1.2.3 From b779c431268da50989257056d21a870a61a1702e Mon Sep 17 00:00:00 2001 From: mo8it Date: Sat, 24 Aug 2024 17:17:56 +0200 Subject: Almost done with list display --- src/list.rs | 35 +++--- src/list/state.rs | 334 ++++++++++++++++++++++++++++++---------------------- src/main.rs | 1 - src/progress_bar.rs | 53 --------- src/term.rs | 48 ++++++++ src/watch/state.rs | 2 +- 6 files changed, 260 insertions(+), 213 deletions(-) delete mode 100644 src/progress_bar.rs (limited to 'src/list.rs') diff --git a/src/list.rs b/src/list.rs index 27a31d1..a571eee 100644 --- a/src/list.rs +++ b/src/list.rs @@ -38,15 +38,15 @@ fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> KeyCode::Home | KeyCode::Char('g') => list_state.select_first(), KeyCode::End | KeyCode::Char('G') => list_state.select_last(), KeyCode::Char('d') => { - let message = if list_state.filter() == Filter::Done { + if list_state.filter() == Filter::Done { list_state.set_filter(Filter::None); - "Disabled filter DONE" + list_state.message.push_str("Disabled filter DONE"); } else { list_state.set_filter(Filter::Done); - "Enabled filter DONE │ Press d again to disable the filter" - }; - - list_state.message.push_str(message); + list_state.message.push_str( + "Enabled filter DONE │ Press d again to disable the filter", + ); + } } KeyCode::Char('p') => { let message = if list_state.filter() == Filter::Pending { @@ -71,23 +71,20 @@ fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> KeyCode::Esc => (), _ => continue, } - - list_state.redraw(stdout)?; } - Event::Mouse(event) => { - match event.kind { - MouseEventKind::ScrollDown => list_state.select_next(), - MouseEventKind::ScrollUp => list_state.select_previous(), - _ => continue, - } - - list_state.redraw(stdout)?; + Event::Mouse(event) => match event.kind { + MouseEventKind::ScrollDown => list_state.select_next(), + MouseEventKind::ScrollUp => list_state.select_previous(), + _ => continue, + }, + Event::Resize(width, height) => { + list_state.set_term_size(width, height); } - // Redraw - Event::Resize(_, _) => list_state.redraw(stdout)?, // Ignore - Event::FocusGained | Event::FocusLost => (), + Event::FocusGained | Event::FocusLost => continue, } + + list_state.redraw(stdout)?; } } diff --git a/src/list/state.rs b/src/list/state.rs index 645c768..d874435 100644 --- a/src/list/state.rs +++ b/src/list/state.rs @@ -1,19 +1,30 @@ use anyhow::{Context, Result}; use crossterm::{ - cursor::{MoveDown, MoveTo}, - style::{Color, ResetColor, SetForegroundColor}, - terminal::{self, BeginSynchronizedUpdate, EndSynchronizedUpdate}, + cursor::{MoveTo, MoveToNextLine}, + style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor}, + terminal::{self, BeginSynchronizedUpdate, Clear, ClearType, EndSynchronizedUpdate}, QueueableCommand, }; use std::{ fmt::Write as _, - io::{self, StdoutLock, Write as _}, + io::{self, StdoutLock, Write}, }; -use crate::{app_state::AppState, term::clear_terminal, MAX_EXERCISE_NAME_LEN}; +use crate::{app_state::AppState, term::progress_bar, MAX_EXERCISE_NAME_LEN}; -// +1 for padding. -const SPACE: &[u8] = &[b' '; MAX_EXERCISE_NAME_LEN + 1]; +fn next_ln(stdout: &mut StdoutLock) -> io::Result<()> { + if CLEAR_LAST_CHAR { + // Avoids having the last written char as the last displayed one when + // the written width is higher than the terminal width. + // Happens on the Gnome terminal for example. + stdout.write_all(b" ")?; + } + + stdout + .queue(Clear(ClearType::UntilNewLine))? + .queue(MoveToNextLine(1))?; + Ok(()) +} #[derive(Copy, Clone, PartialEq, Eq)] pub enum Filter { @@ -30,10 +41,16 @@ pub struct ListState<'a> { name_col_width: usize, offset: usize, selected: Option, + term_width: u16, + term_height: u16, + separator: Vec, } impl<'a> ListState<'a> { pub fn new(app_state: &'a mut AppState, stdout: &mut StdoutLock) -> io::Result { + let (term_width, term_height) = terminal::size()?; + stdout.queue(Clear(ClearType::All))?; + let name_col_width = app_state .exercises() .iter() @@ -41,13 +58,8 @@ impl<'a> ListState<'a> { .max() .map_or(4, |max| max.max(4)); - clear_terminal(stdout)?; - stdout.write_all(b" Current State Name ")?; - stdout.write_all(&SPACE[..name_col_width - 4])?; - stdout.write_all(b"Path\r\n")?; - - let selected = app_state.current_exercise_ind(); let n_rows_with_filter = app_state.exercises().len(); + let selected = app_state.current_exercise_ind(); let mut slf = Self { message: String::with_capacity(128), @@ -57,6 +69,9 @@ impl<'a> ListState<'a> { name_col_width, offset: selected.saturating_sub(10), selected: Some(selected), + term_width, + term_height, + separator: "─".as_bytes().repeat(term_width as usize), }; slf.redraw(stdout)?; @@ -64,6 +79,145 @@ impl<'a> ListState<'a> { Ok(slf) } + pub fn redraw(&mut self, stdout: &mut StdoutLock) -> io::Result<()> { + if self.term_height == 0 { + return Ok(()); + } + + stdout.queue(BeginSynchronizedUpdate)?.queue(MoveTo(0, 0))?; + + // +1 for padding. + const SPACE: &[u8] = &[b' '; MAX_EXERCISE_NAME_LEN + 1]; + stdout.write_all(b" Current State Name")?; + stdout.write_all(&SPACE[..self.name_col_width - 2])?; + stdout.write_all(b"Path")?; + next_ln::(stdout)?; + + let narrow = self.term_width < 96; + let show_footer = self.term_height > 6; + let max_n_rows_to_display = + (self.term_height - 1 - u16::from(show_footer) * (4 + u16::from(narrow))) as usize; + + let displayed_exercises = self + .app_state + .exercises() + .iter() + .enumerate() + .filter(|(_, exercise)| match self.filter { + Filter::Done => exercise.done, + Filter::Pending => !exercise.done, + Filter::None => true, + }) + .skip(self.offset) + .take(max_n_rows_to_display); + + let current_exercise_ind = self.app_state.current_exercise_ind(); + let mut n_displayed_rows = 0; + for (exercise_ind, exercise) in displayed_exercises { + if self.selected == Some(n_displayed_rows) { + stdout.write_all("🦀".as_bytes())?; + } else { + stdout.write_all(b" ")?; + } + + if exercise_ind == current_exercise_ind { + stdout.queue(SetForegroundColor(Color::Red))?; + stdout.write_all(b">>>>>>> ")?; + } else { + stdout.write_all(b" ")?; + } + + if exercise.done { + stdout.queue(SetForegroundColor(Color::Yellow))?; + stdout.write_all(b"DONE ")?; + } else { + stdout.queue(SetForegroundColor(Color::Green))?; + stdout.write_all(b"PENDING ")?; + } + + stdout.queue(ResetColor)?; + + stdout.write_all(exercise.name.as_bytes())?; + stdout.write_all(&SPACE[..self.name_col_width + 2 - exercise.name.len()])?; + + stdout.write_all(exercise.path.as_bytes())?; + + next_ln::(stdout)?; + n_displayed_rows += 1; + } + + for _ in 0..max_n_rows_to_display - n_displayed_rows { + next_ln::(stdout)?; + } + + if show_footer { + stdout.write_all(&self.separator)?; + next_ln::(stdout)?; + + progress_bar( + stdout, + self.app_state.n_done(), + self.app_state.exercises().len() as u16, + self.term_width, + )?; + next_ln::(stdout)?; + + stdout.write_all(&self.separator)?; + next_ln::(stdout)?; + + if self.message.is_empty() { + // Help footer. + stdout.write_all( + "↓/j ↑/k home/g end/G │ ontinue at │ eset exercise │".as_bytes(), + )?; + if narrow { + next_ln::(stdout)?; + stdout.write_all(b"filter ")?; + } else { + stdout.write_all(b" filter ")?; + } + + match self.filter { + Filter::Done => { + stdout + .queue(SetForegroundColor(Color::Magenta))? + .queue(SetAttribute(Attribute::Underlined))?; + stdout.write_all(b"one")?; + stdout.queue(ResetColor)?; + stdout.write_all(b"/

ending")?; + } + Filter::Pending => { + stdout.write_all(b"one/")?; + stdout + .queue(SetForegroundColor(Color::Magenta))? + .queue(SetAttribute(Attribute::Underlined))?; + stdout.write_all(b"

ending")?; + stdout.queue(ResetColor)?; + } + Filter::None => stdout.write_all(b"one/

ending")?, + } + stdout.write_all(" │ uit list".as_bytes())?; + next_ln::(stdout)?; + } else { + stdout.queue(SetForegroundColor(Color::Magenta))?; + stdout.write_all(self.message.as_bytes())?; + stdout.queue(ResetColor)?; + next_ln::(stdout)?; + if narrow { + next_ln::(stdout)?; + } + } + } + + stdout.queue(EndSynchronizedUpdate)?.flush() + } + + pub fn set_term_size(&mut self, width: u16, height: u16) { + self.term_width = width; + self.term_height = height; + self.separator = "─".as_bytes().repeat(width as usize); + } + #[inline] pub fn filter(&self) -> Filter { self.filter @@ -76,13 +230,13 @@ impl<'a> ListState<'a> { .app_state .exercises() .iter() - .filter(|exercise| !exercise.done) + .filter(|exercise| exercise.done) .count(), Filter::Pending => self .app_state .exercises() .iter() - .filter(|exercise| exercise.done) + .filter(|exercise| !exercise.done) .count(), Filter::None => self.app_state.exercises().len(), }; @@ -127,124 +281,38 @@ impl<'a> ListState<'a> { } } - pub fn redraw(&mut self, stdout: &mut StdoutLock) -> io::Result<()> { - stdout.queue(BeginSynchronizedUpdate)?; - stdout.queue(MoveTo(0, 1))?; - let (width, height) = terminal::size()?; - let narrow = width < 95; - let narrow_u16 = u16::from(narrow); - let max_n_rows_to_display = height.saturating_sub(narrow_u16 + 4); - - let displayed_exercises = self - .app_state - .exercises() - .iter() - .enumerate() - .filter(|(_, exercise)| match self.filter { - Filter::Done => exercise.done, - Filter::Pending => !exercise.done, - Filter::None => true, - }) - .skip(self.offset) - .take(max_n_rows_to_display as usize); - - let mut n_displayed_rows: u16 = 0; - let current_exercise_ind = self.app_state.current_exercise_ind(); - for (ind, exercise) in displayed_exercises { - if self.selected == Some(n_displayed_rows as usize) { - write!(stdout, "🦀")?; - } else { - stdout.write_all(b" ")?; - } - - if ind == current_exercise_ind { - stdout.queue(SetForegroundColor(Color::Red))?; - stdout.write_all(b">>>>>>> ")?; - } else { - stdout.write_all(b" ")?; - } - - if exercise.done { - stdout.queue(SetForegroundColor(Color::Yellow))?; - stdout.write_all(b"DONE ")?; - } else { - stdout.queue(SetForegroundColor(Color::Green))?; - stdout.write_all(b"PENDING ")?; - } - - stdout.queue(ResetColor)?; - - stdout.write_all(exercise.name.as_bytes())?; - stdout.write_all(&SPACE[..self.name_col_width + 2 - exercise.name.len()])?; - - stdout.write_all(exercise.path.as_bytes())?; - stdout.write_all(b"\r\n")?; - - n_displayed_rows += 1; + fn selected_to_exercise_ind(&self, selected: usize) -> Result { + match self.filter { + Filter::Done => self + .app_state + .exercises() + .iter() + .enumerate() + .filter(|(_, exercise)| exercise.done) + .nth(selected) + .context("Invalid selection index") + .map(|(ind, _)| ind), + Filter::Pending => self + .app_state + .exercises() + .iter() + .enumerate() + .filter(|(_, exercise)| !exercise.done) + .nth(selected) + .context("Invalid selection index") + .map(|(ind, _)| ind), + Filter::None => Ok(selected), } - - stdout.queue(MoveDown(max_n_rows_to_display - n_displayed_rows))?; - - // TODO - // let message = if self.message.is_empty() { - // // Help footer. - // let mut text = Text::default(); - // let mut spans = Vec::with_capacity(4); - // spans.push(Span::raw( - // "↓/j ↑/k home/g end/G │ ontinue at │ eset exercise │", - // )); - - // if narrow { - // text.push_line(mem::take(&mut spans)); - // spans.push(Span::raw("filter ")); - // } else { - // spans.push(Span::raw(" filter ")); - // } - - // match self.filter { - // Filter::Done => { - // spans.push("one".underlined().magenta()); - // spans.push(Span::raw("/

ending")); - // } - // Filter::Pending => { - // spans.push(Span::raw("one/")); - // spans.push("

ending".underlined().magenta()); - // } - // Filter::None => spans.push(Span::raw("one/

ending")), - // } - - // spans.push(Span::raw(" │ uit list")); - // text.push_line(spans); - // text - // } else { - // Text::from(self.message.as_str().light_blue()) - // }; - - stdout.queue(EndSynchronizedUpdate)?; - stdout.flush()?; - - Ok(()) } pub fn reset_selected(&mut self) -> Result<()> { let Some(selected) = self.selected else { + self.message.push_str("Nothing selected to reset!"); return Ok(()); }; - let ind = self - .app_state - .exercises() - .iter() - .enumerate() - .filter_map(|(ind, exercise)| match self.filter { - Filter::Done => exercise.done.then_some(ind), - Filter::Pending => (!exercise.done).then_some(ind), - Filter::None => Some(ind), - }) - .nth(selected) - .context("Invalid selection index")?; - - let exercise_path = self.app_state.reset_exercise_by_ind(ind)?; + let exercise_ind = self.selected_to_exercise_ind(selected)?; + let exercise_path = self.app_state.reset_exercise_by_ind(exercise_ind)?; write!(self.message, "The exercise {exercise_path} has been reset")?; Ok(()) @@ -257,20 +325,8 @@ impl<'a> ListState<'a> { return Ok(false); }; - let (ind, _) = self - .app_state - .exercises() - .iter() - .enumerate() - .filter(|(_, exercise)| match self.filter { - Filter::Done => exercise.done, - Filter::Pending => !exercise.done, - Filter::None => true, - }) - .nth(selected) - .context("Invalid selection index")?; - - self.app_state.set_current_exercise_ind(ind)?; + let exercise_ind = self.selected_to_exercise_ind(selected)?; + self.app_state.set_current_exercise_ind(exercise_ind)?; Ok(true) } } diff --git a/src/main.rs b/src/main.rs index 5951367..61dd8ea 100644 --- a/src/main.rs +++ b/src/main.rs @@ -20,7 +20,6 @@ mod exercise; mod info_file; mod init; mod list; -mod progress_bar; mod run; mod term; mod terminal_link; diff --git a/src/progress_bar.rs b/src/progress_bar.rs deleted file mode 100644 index 837c4c7..0000000 --- a/src/progress_bar.rs +++ /dev/null @@ -1,53 +0,0 @@ -use std::io::{self, StdoutLock, Write}; - -use crossterm::{ - style::{Color, ResetColor, SetForegroundColor}, - QueueableCommand, -}; - -const PREFIX: &[u8] = b"Progress: ["; -const PREFIX_WIDTH: u16 = PREFIX.len() as u16; -// Leaving the last char empty (_) for `total` > 99. -const POSTFIX_WIDTH: u16 = "] xxx/xx exercises_".len() as u16; -const WRAPPER_WIDTH: u16 = PREFIX_WIDTH + POSTFIX_WIDTH; -const MIN_LINE_WIDTH: u16 = WRAPPER_WIDTH + 4; - -/// Terminal progress bar to be used when not using Ratataui. -pub fn progress_bar( - stdout: &mut StdoutLock, - progress: u16, - total: u16, - line_width: u16, -) -> io::Result<()> { - debug_assert!(progress <= total); - - if line_width < MIN_LINE_WIDTH { - return write!(stdout, "Progress: {progress}/{total} exercises"); - } - - stdout.write_all(PREFIX)?; - - let width = line_width - WRAPPER_WIDTH; - let filled = (width * progress) / total; - - stdout.queue(SetForegroundColor(Color::Green))?; - for _ in 0..filled { - stdout.write_all(b"#")?; - } - - if filled < width { - stdout.write_all(b">")?; - } - - let width_minus_filled = width - filled; - if width_minus_filled > 1 { - let red_part_width = width_minus_filled - 1; - stdout.queue(SetForegroundColor(Color::Red))?; - for _ in 0..red_part_width { - stdout.write_all(b"-")?; - } - } - - stdout.queue(ResetColor)?; - write!(stdout, "] {progress:>3}/{total} exercises") -} diff --git a/src/term.rs b/src/term.rs index 07edf90..b993108 100644 --- a/src/term.rs +++ b/src/term.rs @@ -2,10 +2,58 @@ use std::io::{self, BufRead, StdoutLock, Write}; use crossterm::{ cursor::MoveTo, + style::{Color, ResetColor, SetForegroundColor}, terminal::{Clear, ClearType}, QueueableCommand, }; +/// Terminal progress bar to be used when not using Ratataui. +pub fn progress_bar( + stdout: &mut StdoutLock, + progress: u16, + total: u16, + line_width: u16, +) -> io::Result<()> { + debug_assert!(progress <= total); + + const PREFIX: &[u8] = b"Progress: ["; + const PREFIX_WIDTH: u16 = PREFIX.len() as u16; + // Leaving the last char empty (_) for `total` > 99. + const POSTFIX_WIDTH: u16 = "] xxx/xx exercises_".len() as u16; + const WRAPPER_WIDTH: u16 = PREFIX_WIDTH + POSTFIX_WIDTH; + const MIN_LINE_WIDTH: u16 = WRAPPER_WIDTH + 4; + + if line_width < MIN_LINE_WIDTH { + return write!(stdout, "Progress: {progress}/{total} exercises"); + } + + stdout.write_all(PREFIX)?; + + let width = line_width - WRAPPER_WIDTH; + let filled = (width * progress) / total; + + stdout.queue(SetForegroundColor(Color::Green))?; + for _ in 0..filled { + stdout.write_all(b"#")?; + } + + if filled < width { + stdout.write_all(b">")?; + } + + let width_minus_filled = width - filled; + if width_minus_filled > 1 { + let red_part_width = width_minus_filled - 1; + stdout.queue(SetForegroundColor(Color::Red))?; + for _ in 0..red_part_width { + stdout.write_all(b"-")?; + } + } + + stdout.queue(ResetColor)?; + write!(stdout, "] {progress:>3}/{total} exercises") +} + pub fn clear_terminal(stdout: &mut StdoutLock) -> io::Result<()> { stdout .queue(MoveTo(0, 0))? diff --git a/src/watch/state.rs b/src/watch/state.rs index 26c83d5..40e3d3e 100644 --- a/src/watch/state.rs +++ b/src/watch/state.rs @@ -9,7 +9,7 @@ use crate::{ app_state::{AppState, ExercisesProgress}, clear_terminal, exercise::{RunnableExercise, OUTPUT_CAPACITY}, - progress_bar::progress_bar, + term::progress_bar, terminal_link::TerminalFileLink, }; -- cgit v1.2.3 From fd2a8c01cb35fcff4a5358cce9473ff91272c790 Mon Sep 17 00:00:00 2001 From: mo8it Date: Sat, 24 Aug 2024 19:18:13 +0200 Subject: Separate drawing rows --- src/list.rs | 2 +- src/list/state.rs | 90 +++++++++++++++++++++++++++++++++---------------------- 2 files changed, 55 insertions(+), 37 deletions(-) (limited to 'src/list.rs') diff --git a/src/list.rs b/src/list.rs index a571eee..e360182 100644 --- a/src/list.rs +++ b/src/list.rs @@ -84,7 +84,7 @@ fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> Event::FocusGained | Event::FocusLost => continue, } - list_state.redraw(stdout)?; + list_state.draw(stdout)?; } } diff --git a/src/list/state.rs b/src/list/state.rs index d450741..cbca1d9 100644 --- a/src/list/state.rs +++ b/src/list/state.rs @@ -10,7 +10,10 @@ use std::{ io::{self, StdoutLock, Write}, }; -use crate::{app_state::AppState, term::progress_bar, MAX_EXERCISE_NAME_LEN}; +use crate::{app_state::AppState, exercise::Exercise, term::progress_bar, MAX_EXERCISE_NAME_LEN}; + +// +1 for padding. +const SPACE: &[u8] = &[b' '; MAX_EXERCISE_NAME_LEN + 1]; fn next_ln(stdout: &mut StdoutLock) -> io::Result<()> { if CLEAR_LAST_CHAR { @@ -74,46 +77,24 @@ impl<'a> ListState<'a> { separator: "─".as_bytes().repeat(term_width as usize), }; - slf.redraw(stdout)?; + slf.draw(stdout)?; Ok(slf) } - pub fn redraw(&mut self, stdout: &mut StdoutLock) -> io::Result<()> { - if self.term_height == 0 { - return Ok(()); - } - - stdout.queue(BeginSynchronizedUpdate)?.queue(MoveTo(0, 0))?; - - // +1 for padding. - const SPACE: &[u8] = &[b' '; MAX_EXERCISE_NAME_LEN + 1]; - stdout.write_all(b" Current State Name")?; - stdout.write_all(&SPACE[..self.name_col_width - 2])?; - stdout.write_all(b"Path")?; - next_ln::(stdout)?; - - let narrow = self.term_width < 95; - let show_footer = self.term_height > 6; - let max_n_rows_to_display = - (self.term_height - 1 - u16::from(show_footer) * (4 + u16::from(narrow))) as usize; - - let displayed_exercises = self - .app_state - .exercises() - .iter() - .enumerate() - .filter(|(_, exercise)| match self.filter { - Filter::Done => exercise.done, - Filter::Pending => !exercise.done, - Filter::None => true, - }) - .skip(self.offset) - .take(max_n_rows_to_display); - + fn draw_rows( + &self, + stdout: &mut StdoutLock, + max_n_rows_to_display: usize, + filtered_exercises: impl Iterator, + ) -> io::Result { let current_exercise_ind = self.app_state.current_exercise_ind(); let mut n_displayed_rows = 0; - for (exercise_ind, exercise) in displayed_exercises { + + for (exercise_ind, exercise) in filtered_exercises + .skip(self.offset) + .take(max_n_rows_to_display) + { if self.selected == Some(n_displayed_rows) { stdout.queue(SetBackgroundColor(Color::Rgb { r: 50, @@ -152,6 +133,43 @@ impl<'a> ListState<'a> { n_displayed_rows += 1; } + Ok(n_displayed_rows) + } + + pub fn draw(&mut self, stdout: &mut StdoutLock) -> io::Result<()> { + if self.term_height == 0 { + return Ok(()); + } + + stdout.queue(BeginSynchronizedUpdate)?.queue(MoveTo(0, 0))?; + + // Header + stdout.write_all(b" Current State Name")?; + stdout.write_all(&SPACE[..self.name_col_width - 2])?; + stdout.write_all(b"Path")?; + next_ln::(stdout)?; + + let narrow = self.term_width < 95; + let show_footer = self.term_height > 6; + let max_n_rows_to_display = + (self.term_height - 1 - u16::from(show_footer) * (4 + u16::from(narrow))) as usize; + + // Rows + let iter = self.app_state.exercises().iter().enumerate(); + let n_displayed_rows = match self.filter { + Filter::Done => self.draw_rows( + stdout, + max_n_rows_to_display, + iter.filter(|(_, exercise)| exercise.done), + )?, + Filter::Pending => self.draw_rows( + stdout, + max_n_rows_to_display, + iter.filter(|(_, exercise)| !exercise.done), + )?, + Filter::None => self.draw_rows(stdout, max_n_rows_to_display, iter)?, + }; + for _ in 0..max_n_rows_to_display - n_displayed_rows { next_ln::(stdout)?; } @@ -172,7 +190,7 @@ impl<'a> ListState<'a> { next_ln::(stdout)?; if self.message.is_empty() { - // Help footer. + // Help footer stdout.write_all( "↓/j ↑/k home/g end/G │ ontinue at │ eset exercise │".as_bytes(), )?; -- cgit v1.2.3 From 5f4875e2bae07d3c8ce6505abbc67bbe447b7aa6 Mon Sep 17 00:00:00 2001 From: mo8it Date: Sun, 25 Aug 2024 19:24:12 +0200 Subject: Almost done with list --- src/list.rs | 8 +- src/list/state.rs | 230 +++++++++++++++++++++++++++++++----------------------- 2 files changed, 135 insertions(+), 103 deletions(-) (limited to 'src/list.rs') diff --git a/src/list.rs b/src/list.rs index e360182..a8e5225 100644 --- a/src/list.rs +++ b/src/list.rs @@ -59,9 +59,7 @@ fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> list_state.message.push_str(message); } - KeyCode::Char('r') => { - list_state.reset_selected()?; - } + KeyCode::Char('r') => list_state.reset_selected()?, KeyCode::Char('c') => { if list_state.selected_to_current_exercise()? { return Ok(()); @@ -77,9 +75,7 @@ fn handle_list(app_state: &mut AppState, stdout: &mut StdoutLock) -> Result<()> MouseEventKind::ScrollUp => list_state.select_previous(), _ => continue, }, - Event::Resize(width, height) => { - list_state.set_term_size(width, height); - } + Event::Resize(width, height) => list_state.set_term_size(width, height), // Ignore Event::FocusGained | Event::FocusLost => continue, } diff --git a/src/list/state.rs b/src/list/state.rs index cbca1d9..b8fdfcb 100644 --- a/src/list/state.rs +++ b/src/list/state.rs @@ -15,20 +15,21 @@ use crate::{app_state::AppState, exercise::Exercise, term::progress_bar, MAX_EXE // +1 for padding. const SPACE: &[u8] = &[b' '; MAX_EXERCISE_NAME_LEN + 1]; -fn next_ln(stdout: &mut StdoutLock) -> io::Result<()> { - if CLEAR_LAST_CHAR { - // Avoids having the last written char as the last displayed one when - // the written width is higher than the terminal width. - // Happens on the Gnome terminal for example. - stdout.write_all(b" ")?; - } - +fn next_ln(stdout: &mut StdoutLock) -> io::Result<()> { stdout .queue(Clear(ClearType::UntilNewLine))? .queue(MoveToNextLine(1))?; Ok(()) } +// Avoids having the last written char as the last displayed one when the +// written width is higher than the terminal width. +// Happens on the Gnome terminal for example. +fn next_ln_overwrite(stdout: &mut StdoutLock) -> io::Result<()> { + stdout.write_all(b" ")?; + next_ln(stdout) +} + #[derive(Copy, Clone, PartialEq, Eq)] pub enum Filter { Done, @@ -37,65 +38,111 @@ pub enum Filter { } pub struct ListState<'a> { + /// Footer message to be displayed if not empty. pub message: String, - filter: Filter, app_state: &'a mut AppState, - n_rows_with_filter: usize, name_col_width: usize, - offset: usize, - selected: Option, + filter: Filter, + n_rows_with_filter: usize, + /// Selected row out of the displayed ones. + selected_row: Option, term_width: u16, term_height: u16, - separator: Vec, + separator_line: Vec, + narrow_term: bool, + show_footer: bool, + max_n_rows_to_display: usize, + scroll_padding: usize, + row_offset: usize, } impl<'a> ListState<'a> { pub fn new(app_state: &'a mut AppState, stdout: &mut StdoutLock) -> io::Result { - let (term_width, term_height) = terminal::size()?; stdout.queue(Clear(ClearType::All))?; + let name_col_title_len = 4; let name_col_width = app_state .exercises() .iter() .map(|exercise| exercise.name.len()) .max() - .map_or(4, |max| max.max(4)); + .map_or(name_col_title_len, |max| max.max(name_col_title_len)); + let filter = Filter::None; let n_rows_with_filter = app_state.exercises().len(); - let selected = app_state.current_exercise_ind(); + let selected = Some(app_state.current_exercise_ind()); let mut slf = Self { message: String::with_capacity(128), - filter: Filter::None, app_state, - n_rows_with_filter, name_col_width, - offset: selected.saturating_sub(10), - selected: Some(selected), - term_width, - term_height, - separator: "─".as_bytes().repeat(term_width as usize), + filter, + n_rows_with_filter, + selected_row: selected, + // Set by `set_term_size` + term_width: 0, + term_height: 0, + separator_line: Vec::new(), + narrow_term: false, + show_footer: true, + max_n_rows_to_display: 0, + scroll_padding: 0, + // Updated by `draw` + row_offset: 0, }; + let (width, height) = terminal::size()?; + slf.set_term_size(width, height); slf.draw(stdout)?; Ok(slf) } + pub fn set_term_size(&mut self, width: u16, height: u16) { + self.term_width = width; + self.term_height = height; + + self.separator_line = "─".as_bytes().repeat(width as usize); + + self.narrow_term = width < 95 && self.selected_row.is_some(); + self.show_footer = height > 6; + self.max_n_rows_to_display = + (height - 1 - u16::from(self.show_footer) * (4 + u16::from(self.narrow_term))) as usize; + self.scroll_padding = (self.max_n_rows_to_display / 4).min(5); + } + + fn update_offset(&mut self) { + let Some(selected) = self.selected_row else { + return; + }; + + let min_offset = (selected + self.scroll_padding) + .saturating_sub(self.max_n_rows_to_display.saturating_sub(1)); + let max_offset = selected.saturating_sub(self.scroll_padding); + let global_max_offset = self + .n_rows_with_filter + .saturating_sub(self.max_n_rows_to_display); + + self.row_offset = self + .row_offset + .max(min_offset) + .min(max_offset) + .min(global_max_offset); + } + fn draw_rows( &self, stdout: &mut StdoutLock, - max_n_rows_to_display: usize, filtered_exercises: impl Iterator, ) -> io::Result { let current_exercise_ind = self.app_state.current_exercise_ind(); let mut n_displayed_rows = 0; for (exercise_ind, exercise) in filtered_exercises - .skip(self.offset) - .take(max_n_rows_to_display) + .skip(self.row_offset) + .take(self.max_n_rows_to_display) { - if self.selected == Some(n_displayed_rows) { + if self.selected_row == Some(self.row_offset + n_displayed_rows) { stdout.queue(SetBackgroundColor(Color::Rgb { r: 50, g: 50, @@ -128,7 +175,7 @@ impl<'a> ListState<'a> { stdout.write_all(exercise.path.as_bytes())?; - next_ln::(stdout)?; + next_ln_overwrite(stdout)?; stdout.queue(ResetColor)?; n_displayed_rows += 1; } @@ -147,36 +194,27 @@ impl<'a> ListState<'a> { stdout.write_all(b" Current State Name")?; stdout.write_all(&SPACE[..self.name_col_width - 2])?; stdout.write_all(b"Path")?; - next_ln::(stdout)?; + next_ln_overwrite(stdout)?; - let narrow = self.term_width < 95; - let show_footer = self.term_height > 6; - let max_n_rows_to_display = - (self.term_height - 1 - u16::from(show_footer) * (4 + u16::from(narrow))) as usize; + self.update_offset(); // Rows let iter = self.app_state.exercises().iter().enumerate(); let n_displayed_rows = match self.filter { - Filter::Done => self.draw_rows( - stdout, - max_n_rows_to_display, - iter.filter(|(_, exercise)| exercise.done), - )?, - Filter::Pending => self.draw_rows( - stdout, - max_n_rows_to_display, - iter.filter(|(_, exercise)| !exercise.done), - )?, - Filter::None => self.draw_rows(stdout, max_n_rows_to_display, iter)?, + Filter::Done => self.draw_rows(stdout, iter.filter(|(_, exercise)| exercise.done))?, + Filter::Pending => { + self.draw_rows(stdout, iter.filter(|(_, exercise)| !exercise.done))? + } + Filter::None => self.draw_rows(stdout, iter)?, }; - for _ in 0..max_n_rows_to_display - n_displayed_rows { - next_ln::(stdout)?; + for _ in 0..self.max_n_rows_to_display - n_displayed_rows { + next_ln(stdout)?; } - if show_footer { - stdout.write_all(&self.separator)?; - next_ln::(stdout)?; + if self.show_footer { + stdout.write_all(&self.separator_line)?; + next_ln(stdout)?; progress_bar( stdout, @@ -184,21 +222,25 @@ impl<'a> ListState<'a> { self.app_state.exercises().len() as u16, self.term_width, )?; - next_ln::(stdout)?; + next_ln(stdout)?; - stdout.write_all(&self.separator)?; - next_ln::(stdout)?; + stdout.write_all(&self.separator_line)?; + next_ln(stdout)?; if self.message.is_empty() { // Help footer - stdout.write_all( - "↓/j ↑/k home/g end/G │ ontinue at │ eset exercise │".as_bytes(), - )?; - if narrow { - next_ln::(stdout)?; - stdout.write_all(b"filter ")?; + if self.selected_row.is_some() { + stdout.write_all( + "↓/j ↑/k home/g end/G | ontinue at | eset exercise".as_bytes(), + )?; + if self.narrow_term { + next_ln_overwrite(stdout)?; + stdout.write_all(b"filter ")?; + } else { + stdout.write_all(b" | filter ")?; + } } else { - stdout.write_all(b" filter ")?; + stdout.write_all(b"filter ")?; } match self.filter { @@ -220,19 +262,19 @@ impl<'a> ListState<'a> { } Filter::None => stdout.write_all(b"one/

ending")?, } - stdout.write_all(" │ uit list".as_bytes())?; - if narrow { - next_ln::(stdout)?; + stdout.write_all(b" | uit list")?; + if self.narrow_term { + next_ln_overwrite(stdout)?; } else { - next_ln::(stdout)?; + next_ln(stdout)?; } } else { stdout.queue(SetForegroundColor(Color::Magenta))?; stdout.write_all(self.message.as_bytes())?; stdout.queue(ResetColor)?; - next_ln::(stdout)?; - if narrow { - next_ln::(stdout)?; + next_ln_overwrite(stdout)?; + if self.narrow_term { + next_ln(stdout)?; } } } @@ -240,20 +282,8 @@ impl<'a> ListState<'a> { stdout.queue(EndSynchronizedUpdate)?.flush() } - pub fn set_term_size(&mut self, width: u16, height: u16) { - self.term_width = width; - self.term_height = height; - self.separator = "─".as_bytes().repeat(width as usize); - } - - #[inline] - pub fn filter(&self) -> Filter { - self.filter - } - - pub fn set_filter(&mut self, filter: Filter) { - self.filter = filter; - self.n_rows_with_filter = match filter { + fn update_rows(&mut self) { + self.n_rows_with_filter = match self.filter { Filter::Done => self .app_state .exercises() @@ -270,42 +300,46 @@ impl<'a> ListState<'a> { }; if self.n_rows_with_filter == 0 { - self.selected = None; + self.selected_row = None; } else { - self.selected = Some( - self.selected + self.selected_row = Some( + self.selected_row .map_or(0, |selected| selected.min(self.n_rows_with_filter - 1)), ); } } + #[inline] + pub fn filter(&self) -> Filter { + self.filter + } + + pub fn set_filter(&mut self, filter: Filter) { + self.filter = filter; + self.update_rows(); + } + pub fn select_next(&mut self) { - if self.n_rows_with_filter > 0 { - let next = self.selected.map_or(0, |selected| { - (selected + 1).min(self.n_rows_with_filter - 1) - }); - self.selected = Some(next); + if let Some(selected) = self.selected_row { + self.selected_row = Some((selected + 1).min(self.n_rows_with_filter - 1)); } } pub fn select_previous(&mut self) { - if self.n_rows_with_filter > 0 { - let previous = self - .selected - .map_or(0, |selected| selected.saturating_sub(1)); - self.selected = Some(previous); + if let Some(selected) = self.selected_row { + self.selected_row = Some(selected.saturating_sub(1)); } } pub fn select_first(&mut self) { if self.n_rows_with_filter > 0 { - self.selected = Some(0); + self.selected_row = Some(0); } } pub fn select_last(&mut self) { if self.n_rows_with_filter > 0 { - self.selected = Some(self.n_rows_with_filter - 1); + self.selected_row = Some(self.n_rows_with_filter - 1); } } @@ -334,13 +368,14 @@ impl<'a> ListState<'a> { } pub fn reset_selected(&mut self) -> Result<()> { - let Some(selected) = self.selected else { + let Some(selected) = self.selected_row else { self.message.push_str("Nothing selected to reset!"); return Ok(()); }; let exercise_ind = self.selected_to_exercise_ind(selected)?; let exercise_path = self.app_state.reset_exercise_by_ind(exercise_ind)?; + self.update_rows(); write!(self.message, "The exercise {exercise_path} has been reset")?; Ok(()) @@ -348,13 +383,14 @@ impl<'a> ListState<'a> { // Return `true` if there was something to select. pub fn selected_to_current_exercise(&mut self) -> Result { - let Some(selected) = self.selected else { + let Some(selected) = self.selected_row else { self.message.push_str("Nothing selected to continue at!"); return Ok(false); }; let exercise_ind = self.selected_to_exercise_ind(selected)?; self.app_state.set_current_exercise_ind(exercise_ind)?; + Ok(true) } } -- cgit v1.2.3