ratatui-core 0.1.0

Core types and traits for the Ratatui Terminal UI library. Widget libraries should use this crate. Applications should use the main Ratatui crate.
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

use core::ops::{Add, AddAssign, Neg, Sub, SubAssign};

use super::{Offset, Rect};

impl Neg for Offset {
    type Output = Self;

    /// Negates the offset.
    ///
    /// # Panics
    ///
    /// Panics if the negated value overflows (i.e. `x` or `y` is `i32::MIN`).
    fn neg(self) -> Self {
        Self {
            x: self.x.neg(),
            y: self.y.neg(),
        }
    }
}

impl Add<Offset> for Rect {
    type Output = Self;

    /// Moves the rect by an offset without changing its size.
    ///
    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
    /// rect's position is clamped to the nearest edge.
    fn add(self, offset: Offset) -> Self {
        let max_x = i32::from(u16::MAX - self.width);
        let max_y = i32::from(u16::MAX - self.height);
        let x = i32::from(self.x).saturating_add(offset.x).clamp(0, max_x) as u16;
        let y = i32::from(self.y).saturating_add(offset.y).clamp(0, max_y) as u16;
        Self { x, y, ..self }
    }
}

impl Add<Rect> for Offset {
    type Output = Rect;

    /// Moves the rect by an offset without changing its size.
    ///
    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
    /// rect's position is clamped to the nearest edge.
    fn add(self, rect: Rect) -> Rect {
        rect + self
    }
}

impl Sub<Offset> for Rect {
    type Output = Self;

    /// Subtracts an offset from the rect without changing its size.
    ///
    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
    /// rect's position is clamped to the nearest
    fn sub(self, offset: Offset) -> Self {
        // Note this cannot be simplified to `self + -offset` because `Offset::MIN` would overflow
        let max_x = i32::from(u16::MAX - self.width);
        let max_y = i32::from(u16::MAX - self.height);
        let x = i32::from(self.x).saturating_sub(offset.x).clamp(0, max_x) as u16;
        let y = i32::from(self.y).saturating_sub(offset.y).clamp(0, max_y) as u16;
        Self { x, y, ..self }
    }
}

impl AddAssign<Offset> for Rect {
    /// Moves the rect by an offset in place without changing its size.
    ///
    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
    /// rect's position is clamped to the nearest edge.
    fn add_assign(&mut self, offset: Offset) {
        *self = *self + offset;
    }
}

impl SubAssign<Offset> for Rect {
    /// Moves the rect by an offset in place without changing its size.
    ///
    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
    /// rect's position is clamped to the nearest edge.
    fn sub_assign(&mut self, offset: Offset) {
        *self = *self - offset;
    }
}

#[cfg(test)]
mod tests {
    use rstest::rstest;

    use super::*;

    #[rstest]
    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(4, 6, 5, 6))]
    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(2, 2, 5, 6))]
    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MIN, Rect::new(0, 0, 5, 6))]
    #[case::saturate_positive(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(u16::MAX- 5, u16::MAX - 6, 5, 6))]
    fn add_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
        assert_eq!(rect + offset, expected);
        assert_eq!(offset + rect, expected);
    }

    #[rstest]
    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(2, 2, 5, 6))]
    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(4, 6, 5, 6))]
    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(0, 0, 5, 6))]
    #[case::saturate_positive(Rect::new(3, 4, 5, 6), -Offset::MAX, Rect::new(u16::MAX - 5, u16::MAX - 6, 5, 6))]
    fn sub_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
        assert_eq!(rect - offset, expected);
    }

    #[rstest]
    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(4, 6, 5, 6))]
    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(2, 2, 5, 6))]
    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MIN, Rect::new(0, 0, 5, 6))]
    #[case::saturate_positive(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(u16::MAX - 5, u16::MAX - 6, 5, 6))]
    fn add_assign_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
        let mut rect = rect;
        rect += offset;
        assert_eq!(rect, expected);
    }

    #[rstest]
    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(2, 2, 5, 6))]
    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(4, 6, 5, 6))]
    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(0, 0, 5, 6))]
    #[case::saturate_positive(Rect::new(3, 4, 5, 6), -Offset::MAX, Rect::new(u16::MAX - 5, u16::MAX - 6, 5, 6))]
    fn sub_assign_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
        let mut rect = rect;
        rect -= offset;
        assert_eq!(rect, expected);
    }
}