embedded-graphics 0.6.0-alpha.2

Embedded graphics library for small hardware displays
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

//! Pixel color types.
//!
//! This module contains structs for commonly used pixel color formats and
//! conversions between them. The [`raw` module] provides additional functions
//! to convert colors to and from raw data for use with images and displays.
//!
//! # Implementing custom color types
//!
//! Custom color types can be added by implementing the [`PixelColor`] trait.
//! The following example shows how to implement a new color type for a
//! 3 color EPD display.
//!
//! ```
//! use embedded_graphics::prelude::*;
//! use embedded_graphics::egrectangle;
//!
//! /// Color with 3 states.
//! #[derive(Debug, Clone, Copy, PartialEq, Eq)]
//! pub enum EpdColor {
//!     White,
//!     Black,
//!     Red,
//! }
//!
//! /// The `Raw` can be is set to `()` because `EpdColor` doesn't need to be
//! /// converted to raw data for the display and isn't stored in images.
//! impl PixelColor for EpdColor {
//!     type Raw = ();
//! }
//!
//! /// Mock EPD display.
//! pub struct EpdDisplay {}
//!
//! impl Drawing<EpdColor> for EpdDisplay {
//!     fn draw<T>(&mut self, item: T)
//!     where
//!         T: IntoIterator<Item = Pixel<EpdColor>>
//!     {
//!         for Pixel(point, color) in item {
//!             match color {
//!                 EpdColor::White => {} // draw white pixel at `point`
//!                 EpdColor::Black => {} // draw black pixel at `point`
//!                 EpdColor::Red => {} // draw red pixel at `point`
//!             }
//!         }
//!     }
//! }
//!
//! fn main() {
//!     let mut display = EpdDisplay {};
//!
//!     display.draw(
//!         egrectangle!((0, 0), (100, 100), fill = Some(EpdColor::White))
//!     );
//!
//!     display.draw(
//!         egrectangle!((100, 0), (200, 100), fill = Some(EpdColor::Black))
//!     );
//!
//!     display.draw(
//!         egrectangle!((200, 0), (300, 100), fill = Some(EpdColor::Red))
//!     );
//! }
//! ```
//!
//! The implementation of the [`Drawing`] trait uses a `match` statement to
//! draw the specified color and doesn't depend on the raw data conversions,
//! see the [`raw` module] documentation for an example that uses this feature.
//!
//! [`Drawing`]: ../trait.Drawing.html
//! [`PixelColor`]: trait.PixelColor.html
//! [`Raw`]: trait.PixelColor.html#associatedtype.Raw
//! [`raw` module]: raw/index.html

mod binary_color;
mod conversion;
mod gray_color;
pub mod raw;
mod rgb_color;

pub use binary_color::*;
pub use gray_color::*;
pub use rgb_color::*;

/// Pixel color trait.
///
/// This trait is used to represent types that can be used in drawing methods.
///
/// See the [module-level documentation] for more details.
///
/// [module-level documentation]: index.html
pub trait PixelColor: Copy + PartialEq {
    /// Raw data type.
    ///
    /// Specifies the raw storage type that can be used to represent this color.
    ///
    /// See the [`raw` module documentation] for more details.
    ///
    /// [`raw` module documentation]: raw/index.html
    type Raw: raw::RawData;
}