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

//! attr modules defines the attributes(colors, effects) of a terminal cell

use bitflags::bitflags;

pub use crate::color::Color;

/// `Attr` is a rendering attribute that contains fg color, bg color and text effect.
///
/// ```
/// use tuikit::attr::{Attr, Effect, Color};
///
/// let attr = Attr { fg: Color::RED, effect: Effect::BOLD, ..Attr::default() };
/// ```
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Attr {
    pub fg: Color,
    pub bg: Color,
    pub effect: Effect,
}

impl Default for Attr {
    fn default() -> Self {
        Attr {
            fg: Color::default(),
            bg: Color::default(),
            effect: Effect::empty(),
        }
    }
}

impl Attr {
    /// extend the properties with the new attr's if the properties in new attr is not default.
    /// ```
    /// use tuikit::attr::{Attr, Color, Effect};
    ///
    /// let default = Attr{fg: Color::BLUE, bg: Color::YELLOW, effect: Effect::BOLD};
    /// let new = Attr{fg: Color::Default, bg: Color::WHITE, effect: Effect::REVERSE};
    /// let extended = default.extend(new);
    ///
    /// assert_eq!(Color::BLUE, extended.fg);
    /// assert_eq!(Color::WHITE, extended.bg);
    /// assert_eq!(Effect::BOLD | Effect::REVERSE, extended.effect);
    /// ```
    pub fn extend(&self, new_attr: Self) -> Attr {
        Attr {
            fg: if new_attr.fg != Color::default() {
                new_attr.fg
            } else {
                self.fg
            },
            bg: if new_attr.bg != Color::default() {
                new_attr.bg
            } else {
                self.bg
            },
            effect: self.effect | new_attr.effect,
        }
    }

    pub fn fg(mut self, fg: Color) -> Self {
        self.fg = fg;
        self
    }

    pub fn bg(mut self, bg: Color) -> Self {
        self.bg = bg;
        self
    }

    pub fn effect(mut self, effect: Effect) -> Self {
        self.effect = effect;
        self
    }
}

bitflags! {
    /// `Effect` is the effect of a text
    pub struct Effect: u8 {
        const BOLD = 0b00000001;
        const DIM = 0b00000010;
        const UNDERLINE = 0b00000100;
        const BLINK = 0b00001000;
        const REVERSE = 0b00010000;
    }
}

impl From<Color> for Attr {
    fn from(fg: Color) -> Self {
        Attr {
            fg,
            ..Default::default()
        }
    }
}

impl From<Effect> for Attr {
    fn from(effect: Effect) -> Self {
        Attr {
            effect,
            ..Default::default()
        }
    }
}