nu-explore 0.113.0

Nushell table pager
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::cmp::min;

use super::Cursor;
use anyhow::{Ok, Result, bail};

/// WindowCursor provides a mechanism to navigate through a 1-dimensional range
/// using a smaller movable window within the view.
///
/// View: The larger context or total allowable range for navigation.
/// Window: The smaller, focused subset of the view.
///
/// Example:
/// ```plaintext
/// 1. Initial view of size 20 with a window of size 5. The absolute cursor position starts at 0.
///     View :
///     |--------------------|
///     Window :
///     |X====|
///
/// 2. After advancing the window by 3, the absolute cursor position becomes 3.
///     View :
///     |--------------------|
///     Window :
///        |X====|
///
/// 3. After advancing the cursor inside the window by 2, the absolute cursor position becomes 5.
///     View :
///     |--------------------|
///     Window :
///        |==X==|
/// ```
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct WindowCursor {
    pub view: Cursor,
    pub window: Cursor,
}

impl WindowCursor {
    pub fn new(view_size: usize, window_size: usize) -> Result<Self> {
        if window_size > view_size {
            bail!("Window size cannot be greater than view size");
        }

        Ok(Self {
            view: Cursor::new(view_size),
            window: Cursor::new(window_size),
        })
    }

    pub fn absolute_position(&self) -> usize {
        self.window_starts_at() + self.window.position
    }

    pub fn window_relative_position(&self) -> usize {
        self.window.position
    }

    pub fn window_starts_at(&self) -> usize {
        self.view.position
    }

    pub fn window_size(&self) -> usize {
        self.window.size
    }

    pub fn end(&self) -> usize {
        self.view.end()
    }

    pub fn set_window_start_position(&mut self, i: usize) {
        self.view.set_position(i)
    }

    pub fn move_window_to_end(&mut self) {
        self.view.set_position(self.end() - self.window_size() + 1);
    }

    pub fn set_window_size(&mut self, new_size: usize) -> Result<()> {
        if new_size > self.view.size {
            // TODO: should we return an error here or clamp? the Ok is copying existing behavior
            return Ok(());
        }

        self.window.set_size(new_size)?;
        Ok(())
    }

    pub fn next_n(&mut self, n: usize) {
        for _ in 0..n {
            self.next();
        }
    }

    pub fn next(&mut self) {
        if self.absolute_position() >= self.end() {
            return;
        }

        if self.window_relative_position() == self.window.end() {
            self.view.move_forward(1);
        } else {
            self.window.move_forward(1);
        }
    }

    pub fn next_window(&mut self) {
        self.move_cursor_to_end_of_window();

        // move window forward by window size, or less if that would send it off the end of the view
        let window_end = self.window_starts_at() + self.window_size() - 1;
        let distance_from_window_end_to_view_end = self.end() - window_end;
        self.view.move_forward(min(
            distance_from_window_end_to_view_end,
            self.window_size(),
        ));
    }

    pub fn prev_n(&mut self, n: usize) {
        for _ in 0..n {
            self.prev();
        }
    }

    pub fn prev(&mut self) {
        if self.window_relative_position() == 0 {
            self.view.move_backward(1);
        } else {
            self.window.move_backward(1);
        }
    }

    pub fn prev_window(&mut self) {
        self.move_cursor_to_start_of_window();

        // move the whole window back
        self.view.move_backward(self.window_size());
    }

    pub fn move_cursor_to_start_of_window(&mut self) {
        self.window.move_backward(self.window_size());
    }

    pub fn move_cursor_to_end_of_window(&mut self) {
        self.window.move_forward(self.window_size());
    }
}