semtext 0.1.0

Terminal UI Library
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// theme.rs
//
// Copyright (c) 2020  Douglas P Lau
//
use crate::text::{Appearance, Color, Intensity, Outline, TextStyle};
use crate::widget::BorderStyle;

/// Widget group
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum WidgetGroup {
    /// Normal widget group
    Normal,
    /// Button widget group
    Button,
}

/// Style group
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum StyleGroup {
    /// Enabled widget style
    Enabled,
    /// Disabled widget style
    Disabled,
    /// Primary accent style
    Primary,
    /// Hovered style
    Hovered,
    /// Focused style
    Focused,
    /// Interacted style
    Interacted,
    /// Light shadow style
    LightShadow,
    /// Dark shadow style
    DarkShadow,
}

/// Style theme
#[derive(Clone, Debug, PartialEq)]
pub struct Theme {
    /// Background color
    pub background: Color,
    /// Foreground text color
    pub foreground: Color,
    /// Primary widget color (primary)
    pub primary: Color,
    /// Color for focused elements (secondary)
    pub focused: Color,
    /// Color for interactiing elements (tertiary)
    pub interacting: Color,
    /// Dark shadow color
    pub dark_shadow: Color,
    /// Light shadow color
    pub light_shadow: Color,
    /// Normal border style
    pub normal_border: BorderStyle,
    /// Button border style
    pub button_border: BorderStyle,
}

impl Default for Theme {
    fn default() -> Self {
        let background = Color::Blue(Intensity::Normal);
        let foreground = Color::White(Intensity::Bright);
        let primary = Color::Yellow(Intensity::Normal);
        let focused = Color::Cyan(Intensity::Bright);
        let interacting = Color::Yellow(Intensity::Bright);
        let dark_shadow = Color::Black(Intensity::Bright);
        let light_shadow = Color::White(Intensity::Normal);
        let normal_border = BorderStyle::Simple(Outline::default());
        let button_border = BorderStyle::Bevel(Outline::default());
        Self {
            background,
            foreground,
            primary,
            focused,
            interacting,
            dark_shadow,
            light_shadow,
            normal_border,
            button_border,
        }
    }
}

impl Theme {
    /// Set the background color
    pub fn with_background(mut self, clr: Color) -> Self {
        self.background = clr;
        self
    }

    /// Set the foreground color
    pub fn with_foreground(mut self, clr: Color) -> Self {
        self.foreground = clr;
        self
    }

    /// Set the primary color
    pub fn with_primary(mut self, clr: Color) -> Self {
        self.primary = clr;
        self
    }

    /// Set the color for focused elements (secondary)
    pub fn with_focused(mut self, clr: Color) -> Self {
        self.focused = clr;
        self
    }

    /// Set color for interacting elements (tertiary accent)
    pub fn with_interacting(mut self, clr: Color) -> Self {
        self.interacting = clr;
        self
    }

    /// Get text style
    pub fn style(&self, group: StyleGroup) -> TextStyle {
        let style = TextStyle::default().with_background(self.background);
        match group {
            StyleGroup::Disabled => style.with_foreground(self.light_shadow),
            StyleGroup::Primary => style.with_foreground(self.primary),
            StyleGroup::Hovered => style.with_foreground(self.interacting),
            StyleGroup::Focused => style
                .with_foreground(self.focused)
                .with_appearance(Appearance::default().with_reverse(true)),
            StyleGroup::Interacted => style
                .with_foreground(self.interacting)
                .with_appearance(Appearance::default().with_reverse(true)),
            StyleGroup::LightShadow => style.with_foreground(self.light_shadow),
            StyleGroup::DarkShadow => style.with_foreground(self.dark_shadow),
            _ => style.with_foreground(self.foreground),
        }
    }

    /// Get the border style
    pub fn border_style(&self, group: WidgetGroup) -> BorderStyle {
        match group {
            WidgetGroup::Normal => self.normal_border,
            WidgetGroup::Button => self.button_border,
        }
    }
}