raekna-ui 0.2.1

This crate contains functionality to draw a plain text calculator using wgpu.
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use raekna_common::EditPosition;

#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
pub struct CaretPosition {
    pub line: usize,
    pub column: usize,
    pub actual_column: usize,
}

impl CaretPosition {
    pub fn new(line_widths: &[usize]) -> Self {
        let line = line_widths.len().saturating_sub(1);
        let column = if line_widths.is_empty() {
            0
        } else {
            line_widths[line]
        };
        let actual_column = column;
        Self {
            line,
            column,
            actual_column,
        }
    }

    pub fn set_position(&mut self, line: usize, column: usize) {
        self.line = line;
        self.column = column;
        self.actual_column = column;
    }

    pub fn move_up(&mut self, line_widths: &[usize]) -> bool {
        if self.line == 0 && self.column == 0 {
            false
        } else {
            if self.line == 0 {
                self.column = 0;
            } else {
                self.line = self.line.saturating_sub(1);
                let line_width = line_widths[self.line];
                if line_width < self.actual_column {
                    self.column = line_width;
                } else if self.column != self.actual_column {
                    self.column = self.actual_column;
                }
            }
            true
        }
    }
    pub fn move_down(&mut self, line_widths: &[usize]) -> bool {
        if self.line == line_widths.len().saturating_sub(1) && self.column == line_widths[self.line]
        {
            false
        } else {
            if self.line == line_widths.len().saturating_sub(1) {
                self.column = line_widths[self.line];
            } else {
                self.line += 1;
                let line_width = line_widths[self.line];
                if line_width < self.actual_column {
                    self.column = line_width;
                } else if self.column != self.actual_column {
                    self.column = self.actual_column;
                }
            }
            true
        }
    }

    pub fn move_left(&mut self, line_widths: &[usize]) -> bool {
        if self.line == 0 && self.column == 0 {
            false
        } else {
            if self.column == 0 {
                self.line -= 1;
                self.column = line_widths[self.line];
            } else {
                self.column -= 1;
            }
            self.actual_column = self.column;
            true
        }
    }
    pub fn move_right(&mut self, line_widths: &[usize]) -> bool {
        if self.line == line_widths.len() - 1 && self.column == line_widths[self.line] {
            false
        } else {
            if self.column == line_widths[self.line] {
                self.line += 1;
                self.column = 0;
            } else {
                self.column += 1;
            }
            self.actual_column = self.column;
            true
        }
    }

    pub fn home(&mut self) -> bool {
        if self.column == 0 {
            self.actual_column = self.column;
            false
        } else {
            self.column = 0;
            self.actual_column = self.column;
            true
        }
    }

    pub fn end(&mut self, line_widths: &[usize]) -> bool {
        if self.column == line_widths[self.line] {
            self.actual_column = self.column;
            false
        } else {
            self.column = line_widths[self.line];
            self.actual_column = self.column;
            true
        }
    }

    pub fn page_up(&mut self) -> bool {
        if self.line == 0 && self.column == 0 {
            false
        } else {
            self.line = 0;
            self.column = 0;
            self.actual_column = self.column;
            true
        }
    }

    pub fn page_down(&mut self, line_widths: &[usize]) -> bool {
        if self.line == line_widths.len() - 1 && self.column == line_widths[self.line] {
            false
        } else {
            self.line = line_widths.len() - 1;
            self.column = line_widths[self.line];
            self.actual_column = self.column;
            true
        }
    }
}

impl From<CaretPosition> for EditPosition {
    fn from(cp: CaretPosition) -> Self {
        Self {
            line: cp.line,
            column: cp.column,
        }
    }
}

impl From<EditPosition> for CaretPosition {
    fn from(ep: EditPosition) -> Self {
        Self {
            line: ep.line,
            column: ep.column,
            actual_column: ep.column,
        }
    }
}