embedded-layout 0.4.2

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
125

//! Alignment operations
//!
//! Alignment operations are used to arrange two [`View`]s relative to each other. A single [`align_*`]
//! call requires both a `horizontal` and a `vertical` alignment parameter.
//!
//! The list of currently supported alignments:
//!  - [`horizontal`]
//!    - `NoAlignment`, `Left`, `Center`, `Right`
//!    - `LeftToRight`
//!    - `RightToLeft`
//!  - [`vertical`]
//!    - `NoAlignment`, `Top`, `Center`, `Bottom`
//!    - `TopToBottom`
//!    - `BottomToTop`
//!
//! Alignment works by calling [`align_to`] or [`align_to_mut`] on an object that implements
//! the [`Align`] trait. The call needs a second [`View`] to align to, called the reference [`View`],
//! and two alignment parameters. The second [`View`] will not be translated by the alignment
//! operation.
//!
//! [`horizontal`]: crate::align::horizontal
//! [`vertical`]: crate::align::vertical
//! [`align_*`]: crate::align::Align
//! [`align_to`]: crate::align::Align::align_to
//! [`align_to_mut`]: crate::align::Align::align_to_mut
use crate::prelude::*;
use embedded_graphics::{prelude::Point, primitives::Rectangle};

pub mod horizontal;
pub mod vertical;

/// This trait enables alignment operations for [`View`] objects
///
/// This trait is blanket-implemented for all objects that implement [`View`].
///
/// For more information, see the [module level documentation](crate::align)
pub trait Align {
    /// Return the object aligned to an other one using the alignment parameters as rules
    fn align_to<H, V>(self, reference: &impl View, horizontal: H, vertical: V) -> Self
    where
        H: HorizontalAlignment,
        V: VerticalAlignment;

    /// Align the object to an other one using the alignment parameters as rules
    fn align_to_mut<H, V>(
        &mut self,
        reference: &impl View,
        horizontal: H,
        vertical: V,
    ) -> &mut Self
    where
        H: HorizontalAlignment,
        V: VerticalAlignment;
}

impl<T> Align for T
where
    T: View,
{
    #[inline]
    fn align_to<H, V>(mut self, reference: &impl View, horizontal: H, vertical: V) -> Self
    where
        H: HorizontalAlignment,
        V: VerticalAlignment,
    {
        self.align_to_mut(reference, horizontal, vertical);
        self
    }

    #[inline]
    fn align_to_mut<H, V>(&mut self, reference: &impl View, horizontal: H, vertical: V) -> &mut Self
    where
        H: HorizontalAlignment,
        V: VerticalAlignment,
    {
        let self_bounds = self.bounds();
        let reference_bounds = reference.bounds();

        let h = horizontal.align(self_bounds, reference_bounds);
        let v = vertical.align(self_bounds, reference_bounds);

        self.translate_mut(Point::new(h, v))
    }
}

/// Base trait for alignment operations
///
/// An [`Alignment`] object modifies either the horizontal, or the vertical position of a [`View`].
/// Usually, these objects are passed to methods of [`Align`] or they can be used to parametrize
/// layouts.
///
/// Implementors should also implement either the [`HorizontalAlignment`] or [`VerticalAlignment`]
/// trait, otherwise the implementor can't be used as an alignment operation with `embedded-layout`.
pub trait Alignment: Copy + Clone + Default {
    /// Align one coordinate of `View` to the given reference
    #[inline]
    fn align(&self, what: Rectangle, reference: Rectangle) -> i32 {
        self.align_with_offset(what, reference, 0)
    }

    /// Align one coordinate of `View` to the given reference with some offset
    fn align_with_offset(&self, what: Rectangle, reference: Rectangle, offset: i32) -> i32;
}

/// Implement this trait for horizontal alignment operations
///
/// This trait does not provide any functionality other than that of [`Alignment`], but marks
/// implementors to be used as horizontal alignmenent operations.
///
/// For a list of available horizontal alignments, see the [`horizontal`] module.
///
/// [`horizontal`]: crate::align::horizontal
pub trait HorizontalAlignment: Alignment {}

/// Implement this trait for vertical alignment operations
///
/// Vertical alignment assumes lower coordinate values are higher up on the display.
///
/// This trait does not provide any functionality other than that of [`Alignment`], but marks
/// implementors to be used as vertical alignmenent operations.
///
/// For a list of available vertical alignments, see the [`vertical`] module.
///
/// [`vertical`]: crate::align::vertical
pub trait VerticalAlignment: Alignment {}