ansiq-widgets 0.1.0

Widget builders and shell-oriented UI primitives for Ansiq.
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

use ansiq_core::{Element, ElementKind, Layout, Length, SparklineDirection, SparklineProps, Style};

pub struct Sparkline<Message = ()> {
    element: Element<Message>,
}

impl<Message> Sparkline<Message> {
    pub fn new() -> Self {
        Self {
            element: Element::new(ElementKind::Sparkline(SparklineProps {
                values: Vec::new(),
                max: None,
                direction: SparklineDirection::LeftToRight,
                absent_value_symbol: 'ยท',
                absent_value_style: Style::default(),
            }))
            .with_layout(Layout {
                width: Length::Fill,
                height: Length::Fixed(1),
            }),
        }
    }

    pub fn value(mut self, value: u64) -> Self {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.values.push(Some(value));
        }
        self
    }

    pub fn values<I>(mut self, values: I) -> Self
    where
        I: IntoIterator<Item = u64>,
    {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.values.extend(values.into_iter().map(Some));
        }
        self
    }

    pub fn value_opt(mut self, value: Option<u64>) -> Self {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.values.push(value);
        }
        self
    }

    pub fn values_opt<I>(mut self, values: I) -> Self
    where
        I: IntoIterator<Item = Option<u64>>,
    {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.values.extend(values);
        }
        self
    }

    pub fn max(mut self, max: u64) -> Self {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.max = Some(max);
        }
        self
    }

    pub fn direction(mut self, direction: SparklineDirection) -> Self {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.direction = direction;
        }
        self
    }

    pub fn absent_symbol(mut self, symbol: char) -> Self {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.absent_value_symbol = symbol;
        }
        self
    }

    pub fn absent_style(mut self, style: Style) -> Self {
        if let ElementKind::Sparkline(props) = &mut self.element.kind {
            props.absent_value_style = style;
        }
        self
    }

    pub fn layout(mut self, layout: Layout) -> Self {
        self.element.layout = layout;
        self
    }

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

    pub fn build(self) -> Element<Message> {
        self.element
    }
}