buoyant 0.7.0-alpha.1

SwiftUI-like UIs in Rust for embedded devices
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

use crate::primitives::{Interpolate, Point, Size};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Frame {
    pub size: Size,
    pub origin: Point,
}

impl Frame {
    #[must_use]
    pub const fn new(origin: Point, size: Size) -> Self {
        Self { size, origin }
    }

    #[must_use]
    pub const fn contains(&self, point: &Point) -> bool {
        self.origin.x <= point.x
            && self.origin.y <= point.y
            && point.x < (self.origin.x + self.size.width as i32)
            && point.y < (self.origin.y + self.size.height as i32)
    }

    #[must_use]
    pub const fn x_end(&self) -> i32 {
        self.origin.x + self.size.width as i32
    }

    #[must_use]
    pub const fn y_end(&self) -> i32 {
        self.origin.y + self.size.height as i32
    }
}

#[cfg(feature = "embedded-graphics")]
impl From<Frame> for embedded_graphics_core::primitives::Rectangle {
    fn from(value: Frame) -> Self {
        Self::new(value.origin.into(), value.size.into())
    }
}

#[cfg(feature = "embedded-graphics")]
impl From<embedded_graphics_core::primitives::Rectangle> for Frame {
    fn from(value: embedded_graphics_core::primitives::Rectangle) -> Self {
        Self {
            origin: value.top_left.into(),
            size: value.size.into(),
        }
    }
}

impl Interpolate for Frame {
    fn interpolate(from: Self, to: Self, amount: u8) -> Self {
        Self {
            origin: Interpolate::interpolate(from.origin, to.origin, amount),
            size: Interpolate::interpolate(from.size, to.size, amount),
        }
    }
}