rat-event 2.1.0

ratatui event handler trait for widgets
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
162
163
164

use rat_event::util::{column_at, column_at_drag, row_at, row_at_drag};
use ratatui_core::layout::Rect;

#[test]
fn test_rows0() {
    let area = Rect::new(0, 0, 0, 4);
    let rows = vec![
        Rect::new(0, 0, 0, 1),
        Rect::new(0, 1, 0, 1),
        Rect::new(0, 2, 0, 1),
        Rect::new(0, 3, 0, 1),
    ];

    assert_eq!(row_at(&rows, 0), Some(0));
    assert_eq!(row_at(&rows, 1), Some(1));
    assert_eq!(row_at(&rows, 2), Some(2));
    assert_eq!(row_at(&rows, 3), Some(3));
    assert_eq!(row_at(&rows, 4), None);
    assert_eq!(row_at(&rows, 16384), None);

    assert_eq!(row_at_drag(area, &rows, 0), Ok(0));
    assert_eq!(row_at_drag(area, &rows, 1), Ok(1));
    assert_eq!(row_at_drag(area, &rows, 2), Ok(2));
    assert_eq!(row_at_drag(area, &rows, 3), Ok(3));
    assert_eq!(row_at_drag(area, &rows, 4), Err(1));
    assert_eq!(row_at_drag(area, &rows, 5), Err(2));
    assert_eq!(row_at_drag(area, &rows, 16384), Err(16381));
}

#[test]
fn test_rows1() {
    let area = Rect::new(0, 10, 0, 4);
    let rows = vec![
        Rect::new(0, 10, 0, 1),
        Rect::new(0, 11, 0, 1),
        Rect::new(0, 12, 0, 1),
        Rect::new(0, 13, 0, 1),
    ];

    assert_eq!(row_at(&rows, 0), None);
    assert_eq!(row_at(&rows, 9), None);
    assert_eq!(row_at(&rows, 10), Some(0));
    assert_eq!(row_at(&rows, 11), Some(1));
    assert_eq!(row_at(&rows, 12), Some(2));
    assert_eq!(row_at(&rows, 13), Some(3));
    assert_eq!(row_at(&rows, 14), None);
    assert_eq!(row_at(&rows, 16384), None);

    assert_eq!(row_at_drag(area, &rows, 0), Err(-10));
    assert_eq!(row_at_drag(area, &rows, 9), Err(-1));
    assert_eq!(row_at_drag(area, &rows, 10), Ok(0));
    assert_eq!(row_at_drag(area, &rows, 11), Ok(1));
    assert_eq!(row_at_drag(area, &rows, 12), Ok(2));
    assert_eq!(row_at_drag(area, &rows, 13), Ok(3));
    assert_eq!(row_at_drag(area, &rows, 14), Err(1));
    assert_eq!(row_at_drag(area, &rows, 15), Err(2));
    assert_eq!(row_at_drag(area, &rows, 16384), Err(16371));
}

#[test]
fn test_rows_empty0() {
    let area = Rect::new(0, 0, 0, 10);
    let rows = vec![];
    assert_eq!(row_at(&rows, 23), None);

    assert_eq!(row_at_drag(area, &rows, 0), Err(0));
    assert_eq!(row_at_drag(area, &rows, 1), Err(1));
    assert_eq!(row_at_drag(area, &rows, 16384), Err(16384));
}

#[test]
fn test_rows_empty1() {
    let area = Rect::new(0, 10, 0, 10);
    let rows = vec![];
    assert_eq!(row_at(&rows, 23), None);

    assert_eq!(row_at_drag(area, &rows, 0), Err(-10));
    assert_eq!(row_at_drag(area, &rows, 1), Err(-9));
    assert_eq!(row_at_drag(area, &rows, 10), Err(0));
    assert_eq!(row_at_drag(area, &rows, 11), Err(1));
    assert_eq!(row_at_drag(area, &rows, 19), Err(9));
    assert_eq!(row_at_drag(area, &rows, 16384), Err(16374));
}

#[test]
fn test_cols0() {
    let area = Rect::new(0, 0, 4, 0);
    let cols = vec![
        Rect::new(0, 0, 1, 0),
        Rect::new(1, 0, 1, 0),
        Rect::new(2, 0, 1, 0),
        Rect::new(3, 0, 1, 0),
    ];

    assert_eq!(column_at(&cols, 0), Some(0));
    assert_eq!(column_at(&cols, 1), Some(1));
    assert_eq!(column_at(&cols, 2), Some(2));
    assert_eq!(column_at(&cols, 3), Some(3));
    assert_eq!(column_at(&cols, 4), None);
    assert_eq!(column_at(&cols, 16384), None);

    assert_eq!(column_at_drag(area, &cols, 0), Ok(0));
    assert_eq!(column_at_drag(area, &cols, 1), Ok(1));
    assert_eq!(column_at_drag(area, &cols, 2), Ok(2));
    assert_eq!(column_at_drag(area, &cols, 3), Ok(3));
    assert_eq!(column_at_drag(area, &cols, 4), Err(1));
    assert_eq!(column_at_drag(area, &cols, 5), Err(2));
    assert_eq!(column_at_drag(area, &cols, 16384), Err(16381));
}

#[test]
fn test_cols1() {
    let area = Rect::new(10, 0, 4, 0);
    let cols = vec![
        Rect::new(10, 0, 1, 0),
        Rect::new(11, 0, 1, 0),
        Rect::new(12, 0, 1, 0),
        Rect::new(13, 0, 1, 0),
    ];

    assert_eq!(column_at(&cols, 0), None);
    assert_eq!(column_at(&cols, 9), None);
    assert_eq!(column_at(&cols, 10), Some(0));
    assert_eq!(column_at(&cols, 11), Some(1));
    assert_eq!(column_at(&cols, 12), Some(2));
    assert_eq!(column_at(&cols, 13), Some(3));
    assert_eq!(column_at(&cols, 14), None);
    assert_eq!(column_at(&cols, 16384), None);

    assert_eq!(column_at_drag(area, &cols, 0), Err(-10));
    assert_eq!(column_at_drag(area, &cols, 9), Err(-1));
    assert_eq!(column_at_drag(area, &cols, 10), Ok(0));
    assert_eq!(column_at_drag(area, &cols, 11), Ok(1));
    assert_eq!(column_at_drag(area, &cols, 12), Ok(2));
    assert_eq!(column_at_drag(area, &cols, 13), Ok(3));
    assert_eq!(column_at_drag(area, &cols, 14), Err(1));
    assert_eq!(column_at_drag(area, &cols, 15), Err(2));
    assert_eq!(column_at_drag(area, &cols, 16384), Err(16371));
}

#[test]
fn test_cols_empty0() {
    let area = Rect::new(0, 0, 10, 0);
    let cols = vec![];
    assert_eq!(column_at(&cols, 23), None);

    assert_eq!(column_at_drag(area, &cols, 0), Err(0));
    assert_eq!(column_at_drag(area, &cols, 1), Err(1));
    assert_eq!(column_at_drag(area, &cols, 16384), Err(16384));
}

#[test]
fn test_cols_empty1() {
    let area = Rect::new(10, 0, 10, 0);
    let cols = vec![];
    assert_eq!(column_at(&cols, 23), None);

    assert_eq!(column_at_drag(area, &cols, 0), Err(-10));
    assert_eq!(column_at_drag(area, &cols, 1), Err(-9));
    assert_eq!(column_at_drag(area, &cols, 10), Err(0));
    assert_eq!(column_at_drag(area, &cols, 11), Err(1));
    assert_eq!(column_at_drag(area, &cols, 19), Err(9));
    assert_eq!(column_at_drag(area, &cols, 16384), Err(16374));
}