mplusfonts 0.3.4

Parametrized bitmap font family for embedded-graphics
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

//! Images and image drawables.
//!
//! Image drawables are wrappers around raw data or other image drawables. An image is an
//! aggregation of an image drawable and its offset from the origin. Besides the fact that the
//! image drawable is owned by the image, some of the image drawables in this module expose the
//! contiguous stream of pixel colors, allowing for data manipulation on the image level rather
//! than at the draw target only.
mod mix;
mod raw;
mod set;
mod sub;

use embedded_graphics::Drawable;
use embedded_graphics::draw_target::{DrawTarget, DrawTargetExt};
use embedded_graphics::geometry::{Dimensions, Point};
use embedded_graphics::image::ImageDrawable;
use embedded_graphics::iterator::raw::RawDataSlice;
use embedded_graphics::pixelcolor::PixelColor;
use embedded_graphics::pixelcolor::raw::BigEndian;
use embedded_graphics::primitives::Rectangle;
use embedded_graphics::transform::Transform;

pub use mix::with_colormap::{WithColormap, WithColormapImage, WithColormapImageMix};
pub use mix::{ImageMix, Mixed};
pub use raw::ImageRaw;
pub use set::ImageSet;
pub use sub::{ImageDrawableExt, SubImage};

/// Image that owns the image drawable and holds image offset data.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Image<T: ImageDrawable> {
    image_drawable: T,
    offset: Point,
}

/// Iteration by pixels; colors only.
pub trait Colors<T> {
    /// Returns a data structure that can be turned into an iterator that yields colors of type `T`.
    fn colors(&self) -> impl IntoIterator<Item = T>;
}

impl<'a, C> Image<ImageRaw<'a, C>>
where
    C: PixelColor + From<C::Raw>,
    RawDataSlice<'a, C::Raw, BigEndian>: IntoIterator<Item = C::Raw>,
{
    /// The zero-sized, zero-offset image.
    pub const NULL: Self = Self {
        image_drawable: ImageRaw::new(&[], 0),
        offset: Point::zero(),
    };
}

impl<T: ImageDrawable> Image<T> {
    /// Creates a new image with the specified image drawable and image offset.
    pub const fn new(image_drawable: T, offset: Point) -> Self {
        Self {
            image_drawable,
            offset,
        }
    }

    /// Returns an image that is a clipped area of the same image data.
    pub fn clipped(&self, area: &Rectangle) -> Image<SubImage<'_, T>> {
        let x = self.offset.x.saturating_neg();
        let y = self.offset.y.saturating_neg();
        let offset = Point::new(x, y);
        let area = area.translate(offset);
        let area = self.image_drawable.bounding_box().intersection(&area);
        let image_drawable = self.image_drawable.sub_image(&area);

        Image::new(image_drawable, area.translate(self.offset).top_left)
    }
}

impl<T: ImageDrawable + Clone> Image<T> {
    /// Returns an image with its offset translated.
    pub fn add_offset(&self, x: i32, y: i32) -> Self {
        let x = self.offset.x.saturating_add(x);
        let y = self.offset.y.saturating_add(y);
        let offset = Point::new(x, y);

        Self::new(self.image_drawable.clone(), offset)
    }

    /// Returns an image with its offset scaled.
    pub fn mul_offset(&self, x: i32, y: i32) -> Self {
        let x = self.offset.x.saturating_mul(x);
        let y = self.offset.y.saturating_mul(y);
        let offset = Point::new(x, y);

        Self::new(self.image_drawable.clone(), offset)
    }
}

impl<T: ImageDrawable + Colors<T::Color>> Colors<T::Color> for Image<T> {
    fn colors(&self) -> impl IntoIterator<Item = T::Color> {
        self.image_drawable.colors()
    }
}

impl<T: ImageDrawable> Dimensions for Image<T> {
    fn bounding_box(&self) -> Rectangle {
        self.image_drawable.bounding_box().translate(self.offset)
    }
}

impl<T: ImageDrawable> Drawable for Image<T> {
    type Color = T::Color;
    type Output = ();

    fn draw<D>(&self, target: &mut D) -> Result<Self::Output, D::Error>
    where
        D: DrawTarget<Color = Self::Color>,
    {
        let mut target = target.translated(self.offset);

        self.image_drawable.draw(&mut target)
    }
}