rate-app 0.39.0

RillRate App
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

use super::state::{DashboardState, ResolvedGroup, PATHS};
use anyhow::Error;
use rate_ui::shared_object::{DataChanged, SharedObject};
use rate_ui::widget::{Context, NotificationHandler, Widget, WidgetRuntime};
use rill_protocol::io::provider::EntryId;
use yew::{html, Html};

pub type Dashboard = WidgetRuntime<DashboardWidget>;

pub struct DashboardWidget {
    paths: SharedObject<DashboardState>,
}

impl Default for DashboardWidget {
    fn default() -> Self {
        Self {
            paths: PATHS.with(SharedObject::clone),
        }
    }
}

impl Widget for DashboardWidget {
    type Event = ();
    type Tag = ();
    type Properties = ();
    type Meta = ();

    fn init(&mut self, ctx: &mut Context<Self>) {
        self.paths.subscribe(ctx);
    }

    fn view(&self, _ctx: &Context<Self>) -> Html {
        let state = self.paths.read();
        let dashboard = state.get_dashboard().unwrap_or_default();
        let has_visuals = !dashboard.visuals.is_empty();
        let has_controls = !dashboard.controls.is_empty();
        let visuals = {
            if has_visuals {
                let style = "";
                html! {
                    <div class="flex-grow-1" style=style>
                        { for dashboard.visuals.into_iter().map(render_group) }
                    </div>
                }
            } else {
                Html::default()
            }
        };
        let controls = {
            if has_controls {
                let style = "width: 340px;";
                html! {
                    <div style=style>
                        { for dashboard.controls.into_iter().map(render_group) }
                    </div>
                }
            } else {
                Html::default()
            }
        };
        let transparents = {
            html! {
                <div>
                    { for dashboard.transparents.into_iter().map(render_group) }
                </div>
            }
        };
        if has_visuals || has_controls {
            html! {
                <div yew=module_path!() class="d-flex flex-column">
                    <div class="d-flex flex-column flex-md-row">
                        { visuals }
                        { controls }
                    </div>
                    { transparents }
                </div>
            }
        } else {
            html! {
                <div class="container text-center mt-5">
                    <p class="fs-4">{ "Streams are not available, or the app is disconnected." }</p>
                    <p class="fs-3 mt-3">
                        //{ "Welcome to the "}
                        <span class="fw-bold">
                            { " RillRate " }
                            <span class="text-danger">{ " Live " }</span>
                        </span>
                        //{" embedded dashboard" }
                    </p>
                    //{ for state.structure.packages.iter().map(render_package) }
                </div>
            }
        }
    }
}

fn render_group((name, streams): (EntryId, ResolvedGroup)) -> Html {
    html! {
        <div yew="render_group">
            <div class="text-primary p-2">{ name }</div>
            <super::GroupViewer streams=streams />
        </div>
    }
}

impl NotificationHandler<DataChanged<DashboardState>> for DashboardWidget {
    fn handle(
        &mut self,
        _event: DataChanged<DashboardState>,
        ctx: &mut Context<Self>,
    ) -> Result<(), Error> {
        ctx.redraw();
        Ok(())
    }
}