scrin 0.1.75

A terminal UI toolkit with panes, widgets, overlays, animations, and Aisling-powered effects/loaders.
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

use crate::core::buffer::Buffer;
use crate::core::color::Color;
use crate::core::rect::Rect;
use crate::style::Style;
use crate::widgets::Widget;

#[derive(Debug, Clone)]
pub struct Gauge<'a> {
    pub ratio: f64,
    pub label: &'a str,
    pub style: Style,
    pub gauge_style: Style,
    pub use_unicode: bool,
}

impl<'a> Gauge<'a> {
    pub fn new() -> Self {
        Self {
            ratio: 0.0,
            label: "",
            style: Style::new(),
            gauge_style: Style::new().fg(Color::rgb(88, 166, 255)),
            use_unicode: true,
        }
    }

    pub fn with_ratio(mut self, ratio: f64) -> Self {
        self.ratio = ratio.clamp(0.0, 1.0);
        self
    }

    pub fn with_label(mut self, label: &'a str) -> Self {
        self.label = label;
        self
    }

    pub fn with_style(mut self, style: Style) -> Self {
        self.style = style;
        self
    }

    pub fn with_gauge_style(mut self, style: Style) -> Self {
        self.gauge_style = style;
        self
    }
}

impl<'a> Widget for Gauge<'a> {
    fn render(&self, buffer: &mut Buffer, area: Rect) {
        if area.width < 2 || area.height < 1 {
            return;
        }
        let w = area.width as usize;
        let fill = (w as f64 * self.ratio) as usize;
        let fg = self.gauge_style.fg_or_default();
        let bg = self.style.bg;
        let empty_bg = self.style.bg;

        let (full, half, empty) = if self.use_unicode {
            ('━', '╌', '─')
        } else {
            ('=', '-', ' ')
        };

        for i in 0..w {
            let x = (area.x as usize) + i;
            let y = area.y as usize;
            if i < fill {
                buffer.set(
                    x,
                    y,
                    crate::core::buffer::Cell {
                        ch: full,
                        fg,
                        bg,
                        bold: false,
                        italic: false,
                        underlined: false,
                    },
                );
            } else if i == fill && self.ratio > 0.0 {
                buffer.set(
                    x,
                    y,
                    crate::core::buffer::Cell {
                        ch: half,
                        fg: fg.dim(0.5),
                        bg: empty_bg,
                        bold: false,
                        italic: false,
                        underlined: false,
                    },
                );
            } else {
                buffer.set(
                    x,
                    y,
                    crate::core::buffer::Cell {
                        ch: empty,
                        fg: fg.dim(0.3),
                        bg: empty_bg,
                        bold: false,
                        italic: false,
                        underlined: false,
                    },
                );
            }
        }

        if !self.label.is_empty() {
            let pct = (self.ratio * 100.0) as u32;
            let label = format!(" {} {}%", self.label, pct);
            let display: String = label.chars().take(w).collect();
            let lx = area.x as usize + (w.saturating_sub(display.len())) / 2;
            buffer.set_str(lx, area.y as usize, &display, Color::WHITE, bg);
        }
    }
}

impl<'a> Default for Gauge<'a> {
    fn default() -> Self {
        Self::new()
    }
}