use std::collections::BTreeMap;
use super::panel::Panel;
pub const STEP: usize = 3;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Extent {
pub offset: usize,
pub viewport: usize,
pub content: usize,
pub following: bool,
}
impl Extent {
pub fn max_offset(self) -> usize {
self.content.saturating_sub(self.viewport)
}
pub fn overflows(self) -> bool {
self.content > self.viewport
}
pub fn thumb(self, track: u16) -> (u16, u16) {
if !self.overflows() || track == 0 {
return (0, track);
}
let track = usize::from(track);
let size = (track * self.viewport / self.content).clamp(1, track);
let travel = track - size;
let position = if self.max_offset() == 0 {
0
} else {
travel * self.offset / self.max_offset()
};
(position as u16, size as u16)
}
}
#[derive(Debug, Clone, Default)]
pub struct ScrollState {
panels: BTreeMap<Panel, Extent>,
}
impl ScrollState {
pub const fn follows_the_end(panel: Panel) -> bool {
matches!(panel, Panel::Output)
}
pub const fn is_scrollable(panel: Panel) -> bool {
!matches!(panel, Panel::Editor | Panel::Scratchpad)
}
pub fn extent(&self, panel: Panel) -> Extent {
self.panels.get(&panel).copied().unwrap_or_else(|| Extent {
following: Self::follows_the_end(panel),
..Extent::default()
})
}
pub fn offset(&self, panel: Panel) -> usize {
self.extent(panel).offset
}
fn entry(&mut self, panel: Panel) -> &mut Extent {
self.panels.entry(panel).or_insert(Extent {
following: Self::follows_the_end(panel),
..Extent::default()
})
}
pub fn fit(&mut self, panel: Panel, content: usize, viewport: usize) {
let entry = self.entry(panel);
entry.content = content;
entry.viewport = viewport;
entry.offset = if entry.following {
entry.max_offset()
} else {
entry.offset.min(entry.max_offset())
};
}
pub fn scroll_by(&mut self, panel: Panel, rows: isize) {
let entry = self.entry(panel);
let offset = entry.offset as isize + rows;
entry.offset = offset.max(0) as usize;
entry.offset = entry.offset.min(entry.max_offset());
entry.following = Self::follows_the_end(panel) && entry.offset == entry.max_offset();
}
pub fn page(&mut self, panel: Panel, forward: bool) {
let rows = self.extent(panel).viewport.max(1) as isize;
self.scroll_by(panel, if forward { rows } else { -rows });
}
pub fn reveal(&mut self, panel: Panel, row: usize) {
let entry = self.entry(panel);
if entry.viewport == 0 {
return;
}
if row < entry.offset {
entry.offset = row;
} else if row >= entry.offset + entry.viewport {
entry.offset = row + 1 - entry.viewport;
}
entry.offset = entry.offset.min(entry.max_offset());
entry.following = Self::follows_the_end(panel) && entry.offset == entry.max_offset();
}
pub fn to_start(&mut self, panel: Panel) {
let entry = self.entry(panel);
entry.offset = 0;
entry.following = false;
}
pub fn to_end(&mut self, panel: Panel) {
let entry = self.entry(panel);
entry.offset = entry.max_offset();
entry.following = Self::follows_the_end(panel);
}
pub fn reset(&mut self, panel: Panel) {
let following = Self::follows_the_end(panel);
self.panels.insert(
panel,
Extent {
following,
..Extent::default()
},
);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn fitted(panel: Panel, content: usize, viewport: usize) -> ScrollState {
let mut scroll = ScrollState::default();
scroll.fit(panel, content, viewport);
scroll
}
#[test]
fn a_panel_that_fits_never_scrolls() {
let mut scroll = fitted(Panel::Registers, 6, 10);
scroll.scroll_by(Panel::Registers, 5);
assert_eq!(scroll.offset(Panel::Registers), 0);
assert!(!scroll.extent(Panel::Registers).overflows());
}
#[test]
fn scrolling_stops_at_the_last_screenful() {
let mut scroll = fitted(Panel::Registers, 18, 8);
scroll.scroll_by(Panel::Registers, 100);
assert_eq!(scroll.offset(Panel::Registers), 10);
scroll.scroll_by(Panel::Registers, -100);
assert_eq!(scroll.offset(Panel::Registers), 0);
}
#[test]
fn a_shrinking_panel_pulls_its_offset_back() {
let mut scroll = fitted(Panel::Disassembly, 100, 10);
scroll.scroll_by(Panel::Disassembly, 80);
assert_eq!(scroll.offset(Panel::Disassembly), 80);
scroll.fit(Panel::Disassembly, 100, 40);
assert_eq!(scroll.offset(Panel::Disassembly), 60);
scroll.fit(Panel::Disassembly, 12, 40);
assert_eq!(scroll.offset(Panel::Disassembly), 0);
}
#[test]
fn revealing_a_row_moves_the_least_it_can() {
let mut scroll = fitted(Panel::Explorer, 100, 10);
scroll.reveal(Panel::Explorer, 5);
assert_eq!(scroll.offset(Panel::Explorer), 0, "already in view");
scroll.reveal(Panel::Explorer, 12);
assert_eq!(scroll.offset(Panel::Explorer), 3);
scroll.reveal(Panel::Explorer, 1);
assert_eq!(scroll.offset(Panel::Explorer), 1);
}
#[test]
fn paging_moves_one_screenful() {
let mut scroll = fitted(Panel::Memory, 100, 20);
scroll.page(Panel::Memory, true);
assert_eq!(scroll.offset(Panel::Memory), 20);
scroll.page(Panel::Memory, false);
assert_eq!(scroll.offset(Panel::Memory), 0);
}
#[test]
fn the_output_keeps_showing_its_end_until_the_reader_leaves_it() {
let mut scroll = fitted(Panel::Output, 50, 10);
assert_eq!(
scroll.offset(Panel::Output),
40,
"a log is read from the end"
);
scroll.fit(Panel::Output, 60, 10);
assert_eq!(scroll.offset(Panel::Output), 50, "and follows new lines");
scroll.scroll_by(Panel::Output, -20);
scroll.fit(Panel::Output, 70, 10);
assert_eq!(
scroll.offset(Panel::Output),
30,
"but holds where it was put"
);
scroll.to_end(Panel::Output);
scroll.fit(Panel::Output, 80, 10);
assert_eq!(
scroll.offset(Panel::Output),
70,
"until told to follow again"
);
}
#[test]
fn other_panels_do_not_chase_their_content() {
let scroll = fitted(Panel::Disassembly, 50, 10);
assert_eq!(scroll.offset(Panel::Disassembly), 0);
}
#[test]
fn the_scrollbar_thumb_stays_inside_its_track() {
let scroll = fitted(Panel::Output, 200, 10);
for offset in [0, 5, 95, 190] {
let mut extent = scroll.extent(Panel::Output);
extent.offset = offset.min(extent.max_offset());
let (position, size) = extent.thumb(10);
assert!(size >= 1, "the thumb must be visible");
assert!(position + size <= 10, "at offset {offset}");
}
}
#[test]
fn a_panel_that_fits_has_no_thumb() {
let scroll = fitted(Panel::Stack, 4, 10);
assert_eq!(scroll.extent(Panel::Stack).thumb(10), (0, 10));
}
#[test]
fn the_text_panels_scroll_with_their_cursor_instead() {
assert!(!ScrollState::is_scrollable(Panel::Editor));
assert!(!ScrollState::is_scrollable(Panel::Scratchpad));
for panel in Panel::ALL {
if !matches!(panel, Panel::Editor | Panel::Scratchpad) {
assert!(ScrollState::is_scrollable(panel), "{panel}");
}
}
}
}