embedded-layout 0.0.1

Extend embedded-graphics with simple layout functions
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

//! Horizontal alignment options
use crate::HorizontalAlignment;
use embedded_graphics::geometry::Dimensions;

pub struct NoAlignment;
pub struct Center;
pub struct Left;
pub struct Right;

/// Keep the object's horizontal coordinate unchanged
impl HorizontalAlignment for NoAlignment {
    fn align(&self, _object: &impl Dimensions, _reference: &impl Dimensions) -> i32 {
        0
    }
}

/// Center the objects horizontally
///
/// *Note:* in certain cases it's not possible to center objects perfectly because of
///         the integer cordinates used.
impl HorizontalAlignment for Center {
    fn align(&self, object: &impl Dimensions, reference: &impl Dimensions) -> i32 {
        let center_object = (object.top_left().x + object.bottom_right().x) / 2;
        let center_ref = (reference.top_left().x + reference.bottom_right().x) / 2;

        center_ref - center_object
    }
}

/// Align the left edge of the object to the left edge of the reference
impl HorizontalAlignment for Left {
    fn align(&self, object: &impl Dimensions, reference: &impl Dimensions) -> i32 {
        reference.top_left().x - object.top_left().x
    }
}

/// Align the right edge of the object to the right edge of the reference
impl HorizontalAlignment for Right {
    fn align(&self, object: &impl Dimensions, reference: &impl Dimensions) -> i32 {
        reference.bottom_right().x - object.bottom_right().x
    }
}

#[cfg(test)]
mod test {
    use crate::prelude::*;
    use embedded_graphics::geometry::{Dimensions, Point};
    use embedded_graphics::primitives::Rectangle;

    #[test]
    fn test_center() {
        fn check_center_alignment(source: Rectangle, reference: Rectangle, result: Rectangle) {
            let center_of_reference = reference.top_left() + reference.size() / 2;
            let center_of_result = result.top_left() + result.size() / 2;

            // The size hasn't changed
            assert_eq!(result.size(), source.size());

            // Horizontal coordinate matches reference
            assert_eq!(center_of_result.x, center_of_reference.x);

            // Vertical coordinate is unchanged
            assert_eq!(result.top_left.y, source.top_left.y);
        }

        let rect1 = Rectangle::new(Point::new(0, 0), Point::new(10, 10));
        let rect2 = Rectangle::new(Point::new(30, 20), Point::new(40, 50));

        let result = rect1.align_to(rect2, horizontal::Center, vertical::NoAlignment);
        check_center_alignment(rect1, rect2, result);

        // Test the other direction
        let result = rect2.align_to(rect1, horizontal::Center, vertical::NoAlignment);
        check_center_alignment(rect2, rect1, result);
    }

    #[test]
    fn test_left() {
        fn check_left_alignment(source: Rectangle, reference: Rectangle, result: Rectangle) {
            // The size hasn't changed
            assert_eq!(result.size(), source.size());

            // Horizontal coordinate matches reference
            assert_eq!(result.top_left.x, reference.top_left.x);

            // Vertical coordinate is unchanged
            assert_eq!(result.top_left.y, source.top_left.y);
        }

        let rect1 = Rectangle::new(Point::new(0, 0), Point::new(10, 10));
        let rect2 = Rectangle::new(Point::new(30, 20), Point::new(40, 50));

        let result = rect1.align_to(rect2, horizontal::Left, vertical::NoAlignment);
        check_left_alignment(rect1, rect2, result);

        // Test the other direction
        let result = rect2.align_to(rect1, horizontal::Left, vertical::NoAlignment);
        check_left_alignment(rect2, rect1, result);
    }

    #[test]
    fn test_right() {
        fn check_right_alignment(source: Rectangle, reference: Rectangle, result: Rectangle) {
            // The size hasn't changed
            assert_eq!(result.size(), source.size());

            // Horizontal coordinate matches reference
            assert_eq!(result.bottom_right.x, reference.bottom_right.x);

            // Vertical coordinate is unchanged
            assert_eq!(result.bottom_right.y, source.bottom_right.y);
        }

        let rect1 = Rectangle::new(Point::new(0, 0), Point::new(10, 10));
        let rect2 = Rectangle::new(Point::new(30, 20), Point::new(40, 50));

        let result = rect1.align_to(rect2, horizontal::Right, vertical::NoAlignment);
        check_right_alignment(rect1, rect2, result);

        // Test the other direction
        let result = rect2.align_to(rect1, horizontal::Right, vertical::NoAlignment);
        check_right_alignment(rect2, rect1, result);
    }
}