skima 0.1.0

Rust structural UI library for web
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

use std::cell::RefCell;
use std::rc::Rc;

use wasm_bindgen::prelude::Closure;
use wasm_bindgen::JsCast;
use web_sys::HtmlElement;

use crate::tree::Tree;
use crate::web::{Callback, Markup, WebSys};

pub(crate) struct EventListener<F>
where
	F: Fn(web_sys::Event) + ?Sized,
{
	pub(crate) event: &'static str,
	pub(crate) callback: Rc<F>,
}

impl<F> EventListener<F>
where
	F: Fn(web_sys::Event),
{
	pub fn new(event: &'static str, func: F) -> Self {
		EventListener {
			event,
			callback: Rc::new(func),
		}
	}
}

struct EventListenerData<F>
where
	F: Fn(web_sys::Event) + ?Sized + 'static,
{
	func: RefCell<Rc<F>>,
	closure: Closure<dyn Fn(web_sys::Event)>,
}

impl<F> Markup<WebSys> for EventListener<F>
where
	F: Fn(web_sys::Event) + ?Sized + 'static,
{
	fn has_own_node() -> bool {
		false
	}

	fn render(&self, tree: &Tree<WebSys>) {
		tracing::info!("Rendering event {}", self.event);
		tracing::info!("Event tree {:?}", tree);

		let data =
			Rc::<EventListenerData<F>>::new_cyclic(|this| {
				let data = this.clone();
				let closure = Closure::wrap(Box::new(move |event| {
					(data.upgrade().unwrap().func.borrow())(event)
				}) as Box<dyn Fn(web_sys::Event)>);

				EventListenerData {
					func: RefCell::new(self.callback.clone()),
					closure,
				}
			});

		tree.closest_node()
			.unchecked_ref::<HtmlElement>()
			.add_event_listener_with_callback(&self.event, data.closure.as_ref().unchecked_ref())
			.unwrap();

		tree.set_data(data);
	}

	fn diff(&self, _prev: &Self, tree: &Tree<WebSys>) {
		let data = tree.data::<EventListenerData<F>>();
		*data.func.borrow_mut() = self.callback.clone();
	}

	fn drop(&self, tree: &Tree<WebSys>, _should_unmount: bool) {
		let data = tree.remove_data::<EventListenerData<F>>();
		tree.closest_node()
			.unchecked_ref::<HtmlElement>()
			.remove_event_listener_with_callback(self.event, data.closure.as_ref().unchecked_ref())
			.unwrap()
	}
}

pub trait IntoEventCallback {
	type Fn: Fn(web_sys::Event) + ?Sized + 'static;
	fn into_fn(self) -> Rc<Self::Fn>;
}

impl<F> IntoEventCallback for F
where
	F: Fn(web_sys::Event) + 'static,
{
	type Fn = Self;
	fn into_fn(self) -> Rc<Self::Fn> {
		Rc::new(self)
	}
}

impl IntoEventCallback for Callback<dyn Fn(web_sys::Event)> {
	type Fn = dyn Fn(web_sys::Event);
	fn into_fn(self) -> Rc<Self::Fn> {
		self.0.clone()
	}
}

pub fn on(event: &'static str, callback: impl IntoEventCallback) -> impl Markup {
	EventListener {
		event,
		callback: callback.into_fn(),
	}
}

pub fn on_if<T: 'static, F>(val: Option<T>, event: &'static str, callback: F) -> impl Markup
where
	F: Fn(&T, web_sys::Event) + 'static,
{
	val.map(|val| EventListener {
		event,
		callback: Rc::new(move |v| (callback)(&val, v)),
	})
}