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

//! B/W/G/DG Color for EPDs

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum EpdColor {
    Black = 0,
    DarkGray = 1,
    Gray = 2,
    White = 3,
}

impl EpdColor {
    /// Get the color encoding of the color for one bit
    pub fn get_bit_value(self) -> u8 {
        match self {
            EpdColor::White => 3u8,
            EpdColor::Black => 0u8,
            EpdColor::DarkGray => 1u8,
            EpdColor::Gray => 2u8,
        }
    }

    /// Gets a full byte of black or white pixels
    pub fn get_byte_value(self) -> u8 {
        match self {
            EpdColor::White => 0xff,
            EpdColor::Black => 0x00,
            EpdColor::DarkGray => 0x55,
            EpdColor::Gray => 0xaa,
        }
    }

    /// Parses from u8 to Color
    fn from_u8(val: u8) -> Self {
        match val {
            0 => EpdColor::Black,
            1 => EpdColor::DarkGray,
            2 => EpdColor::Gray,
            3 => EpdColor::White,
            e => panic!(
                "DisplayColor only parses 0 and 3 (Black and White) and not `{}`",
                e
            ),
        }
    }

    /// Returns the inverse of the given color.
    ///
    /// Black returns White and White returns Black
    pub fn inverse(self) -> EpdColor {
        match self {
            EpdColor::White => EpdColor::Black,
            EpdColor::Black => EpdColor::White,
            EpdColor::Gray => EpdColor::DarkGray,
            EpdColor::DarkGray => EpdColor::Gray,
        }
    }
}

#[cfg(feature = "graphics")]
use embedded_graphics::prelude::PixelColor;
#[cfg(feature = "graphics")]
impl PixelColor for EpdColor {
    type Raw = ();
}

impl From<u8> for EpdColor {
    fn from(value: u8) -> Self {
        EpdColor::from_u8(value)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn from_u8() {
        assert_eq!(EpdColor::Black, EpdColor::from(0u8));
        assert_eq!(EpdColor::White, EpdColor::from(3u8));
        assert_eq!(EpdColor::Gray, EpdColor::from(2u8));
        assert_eq!(EpdColor::DarkGray, EpdColor::from(1u8));
    }

    // test all values aside from 0,1,2 and 3 which all should panic
    #[test]
    fn from_u8_panic() {
        for val in 4..=u8::max_value() {
            extern crate std;
            let result = std::panic::catch_unwind(|| EpdColor::from(val));
            assert!(result.is_err());
        }
    }

    #[test]
    fn u8_conversion_black() {
        assert_eq!(
            EpdColor::from(EpdColor::Black.get_bit_value()),
            EpdColor::Black
        );
        assert_eq!(EpdColor::from(0u8).get_bit_value(), 0u8);
    }

    #[test]
    fn u8_conversion_white() {
        assert_eq!(
            EpdColor::from(EpdColor::White.get_bit_value()),
            EpdColor::White
        );
        assert_eq!(EpdColor::from(3u8).get_bit_value(), 3u8);
    }
}