draco 0.1.2

Draco is a Rust library for building client side web applications with Web Assembly.
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 js_sys as js;
use wasm_bindgen::prelude::*;

struct Clock {
    date: js::Date,
    subscription: Option<draco::Unsubscribe>,
}

enum Message {
    Toggle,
    Tick,
}

impl Clock {
    fn new() -> Self {
        Clock {
            date: js::Date::new_0(),
            subscription: None,
        }
    }
}

impl draco::App for Clock {
    type Message = Message;

    fn update(&mut self, mailbox: &draco::Mailbox<Message>, message: Self::Message) {
        match message {
            Message::Toggle => {
                if let Some(_) = self.subscription.take() {
                } else {
                    self.subscription = Some(
                        mailbox
                            .subscribe(draco::subscription::Interval::new(16), |()| Message::Tick),
                    );
                }
            }
            Message::Tick => {
                self.date = js::Date::new_0();
            }
        }
    }

    fn render(&self) -> draco::Node<Self::Message> {
        use draco::{html as h, svg as s};
        let circle = s::circle()
            .attr("cx", "100")
            .attr("cy", "100")
            .attr("r", "98")
            .attr("fill", "none")
            .attr("stroke", "black");

        let line = |rotate: f64, stroke, stroke_width, height: u32| {
            s::line()
                .attr("x1", "100")
                .attr("y1", "100")
                .attr("x2", (100 - height).to_string())
                .attr("y2", "100")
                .attr("stroke", stroke)
                .attr("stroke-width", stroke_width)
                .attr("stroke-linecap", "round")
                .attr(
                    "transform",
                    format!("rotate({} 100 100)", (rotate * 10.0).round() / 10.0),
                )
        };

        let d = &self.date;
        let ms = ((((d.get_hours() * 60 + d.get_minutes()) * 60) + d.get_seconds()) * 1000
            + d.get_milliseconds()) as f64;

        let second_rotate = 90.0 + ((ms / 1000.0) % 60.0) * 360.0 / 60.0;
        let minute_rotate = 90.0 + ((ms / 1000.0 / 60.0) % 60.0) * 360.0 / 60.0;
        let hour_rotate = 90.0 + ((ms / 1000.0 / 60.0 / 60.0) % 12.0) * 360.0 / 12.0;

        h::div()
            .attr(
                "style",
                "display: flex; align-items: center; flex-direction: column;",
            )
            .push(
                h::div().push(
                    h::button()
                        .attr("style", "margin: 1rem;")
                        .push(if self.subscription.is_some() {
                            "Stop"
                        } else {
                            "Start"
                        })
                        .on("click", |_| Message::Toggle),
                ),
            )
            .push(
                s::svg()
                    .attr("width", "400")
                    .attr("height", "400")
                    .attr("viewBox", "0 0 200 200")
                    .push(circle)
                    .push(line(hour_rotate, "#333", "4", 50))
                    .push(line(minute_rotate, "#333", "3", 70))
                    .push(line(second_rotate, "crimson", "2", 90)),
            )
            .into()
    }
}

#[wasm_bindgen]
pub fn start() {
    let mailbox = draco::start(Clock::new(), draco::select("main").expect("main").into());
    mailbox.send(Message::Toggle);
}

pub fn main() {}