wi-masonry 0.0.0

A vi-style node editor — Masonry widgets
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

use std::{borrow::Cow, fmt::Write};

use masonry::{
    core::{StyleProperty, WidgetMut, WidgetPod},
    peniko::color::{AlphaColor, Srgb},
    theme::TEXT_COLOR,
    widgets::{Flex, Label, SizedBox},
};
use wi_core::{ModeKind, Status};

pub struct RenderedStatus {
    mode: &'static str,
    mode_brush: AlphaColor<Srgb>,
    last_action: Cow<'static, str>,
    chord: String,
}

impl RenderedStatus {
    pub fn new(status: Status) -> Self {
        let Status {
            count,
            mode,
            last_action,
            pending_op,
            debug: _,
        } = status;
        let mut chord = String::new();

        if let Some(count) = count {
            write!(chord, "{count}").unwrap();
        }

        let last_action = if let Some(action) = last_action {
            action.name()
        } else {
            "".into()
        };

        write!(chord, "{pending_op}").unwrap();

        let default_mode = matches!(mode, ModeKind::Normal);
        let mode = match mode {
            ModeKind::Normal => "Normal",
        };

        Self {
            mode,
            mode_brush: TEXT_COLOR.with_alpha(if default_mode { 0.4 } else { 1.0 }),
            last_action,
            chord,
        }
    }

    pub fn create(self) -> WidgetPod<Flex> {
        let Self {
            mode,
            mode_brush,
            last_action,
            chord,
        } = self;

        WidgetPod::new(
            Flex::row()
                .gap(8.0)
                .with_spacer(4.0)
                .with_child(
                    Label::new(mode)
                        .with_style(StyleProperty::FontSize(18.0))
                        .with_brush(mode_brush),
                )
                .with_flex_spacer(1.0)
                .with_child(
                    Label::new(last_action)
                        .with_style(StyleProperty::FontSize(18.0))
                        .with_brush(TEXT_COLOR.with_alpha(0.6)),
                )
                .with_child(
                    SizedBox::new(Label::new(chord).with_style(StyleProperty::FontSize(18.0)))
                        .width(50.0),
                )
                .with_spacer(4.0),
        )
    }

    pub fn update(self, mut bar: WidgetMut<Flex>) {
        let Self {
            mode,
            mode_brush,
            last_action,
            chord,
        } = self;

        {
            let mut lbl = Flex::child_mut(&mut bar, 1).unwrap();
            let mut lbl = lbl.downcast();
            Label::set_text(&mut lbl, mode);
            Label::set_brush(&mut lbl, mode_brush);
        }

        Label::set_text(
            &mut Flex::child_mut(&mut bar, 3).unwrap().downcast(),
            last_action,
        );

        Label::set_text(
            &mut SizedBox::child_mut(&mut Flex::child_mut(&mut bar, 4).unwrap().downcast())
                .unwrap()
                .downcast(),
            chord,
        );
    }
}