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

pub use termcolor::Color;

/// Struct for configuring a [`Cell`](struct.Cell.html)'s format
#[derive(Debug, Clone, Copy)]
pub struct CellFormat {
    pub(crate) justify: Justify,
    pub(crate) align: Align,
    pub(crate) foreground_color: Option<Color>,
    pub(crate) background_color: Option<Color>,
    pub(crate) bold: bool,
    pub(crate) underline: bool,
}

impl Default for CellFormat {
    fn default() -> Self {
        Self {
            justify: Default::default(),
            align: Default::default(),
            foreground_color: None,
            background_color: None,
            bold: false,
            underline: false,
        }
    }
}

impl CellFormat {
    /// Creates a new builder for [`CellFormat`](struct.CellFormat.html)
    #[inline]
    pub fn builder() -> CellFormatBuilder {
        Default::default()
    }
}

/// Builder for [`CellFormat`](struct.CellFormat.html)
#[derive(Debug, Default)]
pub struct CellFormatBuilder(CellFormat);

impl CellFormatBuilder {
    /// Justify contents of a [`Cell`](struct.Cell.html)
    #[inline]
    pub fn justify(mut self, justify: Justify) -> Self {
        self.0.justify = justify;
        self
    }

    /// Align contents of a [`Cell`](struct.Cell.html)
    #[inline]
    pub fn align(mut self, align: Align) -> Self {
        self.0.align = align;
        self
    }

    /// Set foreground color of a [`Cell`](struct.Cell.html)
    #[inline]
    pub fn foreground_color(mut self, foreground_color: Option<Color>) -> Self {
        self.0.foreground_color = foreground_color;
        self
    }

    /// Set background color of a [`Cell`](struct.Cell.html)
    #[inline]
    pub fn background_color(mut self, background_color: Option<Color>) -> Self {
        self.0.background_color = background_color;
        self
    }

    /// Set contents of [`Cell`](struct.Cell.html) to be bold
    #[inline]
    pub fn bold(mut self, bold: bool) -> Self {
        self.0.bold = bold;
        self
    }

    /// Set contents of [`Cell`](struct.Cell.html) to be underlined
    #[inline]
    pub fn underline(mut self, underline: bool) -> Self {
        self.0.underline = underline;
        self
    }

    /// Build [`CellFormat`](struct.CellFormat.html)
    #[inline]
    pub fn build(self) -> CellFormat {
        self.0
    }
}

/// Used to horizontally justify contents of a [`Cell`](struct.Cell.html)
#[derive(Debug, Clone, Copy)]
pub enum Justify {
    /// Justifies contents to left
    Left,
    /// Justifies contents to right
    Right,
    /// Justifies contents to center
    Center,
}

impl Default for Justify {
    #[inline]
    fn default() -> Self {
        Self::Left
    }
}

/// Used to vertically align contents of a [`Cell`](struct.Cell.html)
#[derive(Debug, Clone, Copy)]
pub enum Align {
    /// Aligns contents to top
    Top,
    /// Aligns contents to bottom
    Bottom,
    /// Aligns contents to center
    Center,
}

impl Default for Align {
    #[inline]
    fn default() -> Self {
        Self::Top
    }
}