mkutils 0.1.138

Utility methods, traits, and types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::{
    geometry::{Orientation, PointUsize},
    scroll_bar::ScrollBar,
    utils::Utils,
};
use derive_more::From;
use mkutils_macros::Toggle;
use num::traits::SaturatingSub;
use ratatui::style::Style;

#[derive(Clone, Copy, Toggle)]
pub enum ScrollWhen {
    Always,
    ForLargeContent,
}

#[derive(Clone, Copy, From)]
pub enum ScrollCountType {
    Fixed(usize),
    PageSize,
}

pub struct ScrollViewState {
    scroll_offset: PointUsize,
    scroll_when: ScrollWhen,
    latest_content_size: PointUsize,
    latest_scroll_view_area_size: PointUsize,
}

impl ScrollViewState {
    const INITIAL_SCROLL_OFFSET: PointUsize = PointUsize::ZERO;
    const INITIAL_LATEST_CONTENT_SIZE: PointUsize = PointUsize::ZERO;
    const INITIAL_LATEST_SCROLL_VIEW_AREA_SIZE: PointUsize = PointUsize::ZERO;

    #[must_use]
    pub const fn new(scroll_when: ScrollWhen) -> Self {
        let scroll_offset = Self::INITIAL_SCROLL_OFFSET;
        let latest_content_size = Self::INITIAL_LATEST_CONTENT_SIZE;
        let latest_scroll_view_area_size = Self::INITIAL_LATEST_SCROLL_VIEW_AREA_SIZE;

        Self {
            scroll_offset,
            scroll_when,
            latest_content_size,
            latest_scroll_view_area_size,
        }
    }

    fn scroll_count(&self, scroll_count_type: ScrollCountType, orientation: Orientation) -> usize {
        match scroll_count_type {
            ScrollCountType::Fixed(scroll_count) => scroll_count,
            ScrollCountType::PageSize => self.latest_scroll_view_area_size.get(orientation).copied(),
        }
    }

    #[must_use]
    pub fn max_scroll_offset(&self) -> PointUsize {
        match self.scroll_when {
            ScrollWhen::Always => self.latest_content_size.saturating_sub_scalar(&1),
            ScrollWhen::ForLargeContent => self
                .latest_content_size
                .saturating_sub(&self.latest_scroll_view_area_size),
        }
    }

    fn scroll(&mut self, scroll_count_type: ScrollCountType, orientation: Orientation, add: bool) {
        let scroll_count = self.scroll_count(scroll_count_type, orientation);
        let max_scroll_offset = self.max_scroll_offset().get(orientation).copied();
        let scroll_offset = self.scroll_offset.get_mut(orientation);

        scroll_offset
            .saturating_add_or_sub(&scroll_count, add)
            .min(max_scroll_offset)
            .assign_to(scroll_offset);
    }

    #[must_use]
    pub const fn scroll_offset(&self) -> PointUsize {
        self.scroll_offset
    }

    #[must_use]
    pub const fn latest_content_size(&self) -> PointUsize {
        self.latest_content_size
    }

    pub const fn set_latest_content_size(&mut self, latest_content_size: PointUsize) {
        self.latest_content_size = latest_content_size;
    }

    pub const fn set_latest_scroll_view_area_size(&mut self, latest_scroll_view_area_size: PointUsize) {
        self.latest_scroll_view_area_size = latest_scroll_view_area_size;
    }

    pub fn scroll_down(&mut self, scroll_count_type: impl Into<ScrollCountType>) {
        self.scroll(scroll_count_type.into(), Orientation::Vertical, true);
    }

    pub fn scroll_up(&mut self, scroll_count_type: impl Into<ScrollCountType>) {
        self.scroll(scroll_count_type.into(), Orientation::Vertical, false);
    }

    pub fn scroll_left(&mut self, scroll_count_type: impl Into<ScrollCountType>) {
        self.scroll(scroll_count_type.into(), Orientation::Horizontal, false);
    }

    pub fn scroll_right(&mut self, scroll_count_type: impl Into<ScrollCountType>) {
        self.scroll(scroll_count_type.into(), Orientation::Horizontal, true);
    }

    #[must_use]
    pub fn scroll_bar(&self, orientation: Orientation, style: Style) -> ScrollBar {
        ScrollBar::new(
            self.scroll_offset(),
            self.max_scroll_offset(),
            self.latest_content_size(),
            orientation,
            style,
        )
    }
}