65 lines
1.7 KiB
Rust
65 lines
1.7 KiB
Rust
use std::sync::Arc;
|
|
|
|
use crate::{
|
|
component::{Context, Scope},
|
|
state::HookDependency,
|
|
View,
|
|
};
|
|
|
|
pub enum RsxScope {
|
|
Static(Box<dyn Fn(&Arc<Scope>) + Send + Sync>),
|
|
Dynamic(
|
|
Arc<dyn Fn(&Arc<Scope>) + Send + Sync>,
|
|
Vec<Box<dyn HookDependency>>,
|
|
),
|
|
}
|
|
|
|
pub struct Rsx(Vec<RsxScope>);
|
|
|
|
impl Rsx {
|
|
pub fn new() -> Self {
|
|
Self(Vec::new())
|
|
}
|
|
|
|
pub fn static_scope<F: Fn(&Arc<Scope>) + Send + Sync + 'static>(&mut self, scope: F) {
|
|
self.0.push(RsxScope::Static(Box::new(scope)));
|
|
}
|
|
|
|
pub fn dynamic_scope<F: Fn(&Arc<Scope>) + Send + Sync + 'static>(
|
|
&mut self,
|
|
drawer: F,
|
|
dependencies: Vec<Box<dyn HookDependency>>,
|
|
) {
|
|
self.0
|
|
.push(RsxScope::Dynamic(Arc::new(drawer), dependencies));
|
|
}
|
|
|
|
pub fn view(&self, context: Arc<Context>) -> View {
|
|
let executor = context.get_executor();
|
|
|
|
for scope in &self.0 {
|
|
match scope {
|
|
RsxScope::Static(scope_fn) => {
|
|
let scope = Scope::new(executor.clone());
|
|
(scope_fn)(&scope);
|
|
context.scopes.lock().unwrap().push(scope)
|
|
}
|
|
RsxScope::Dynamic(drawer, dependencies) => {
|
|
let drawer = drawer.clone();
|
|
context.dyn_scope(
|
|
move |c| drawer(c),
|
|
&dependencies.iter().map(|d| d.as_ref()).collect::<Vec<_>>(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
let context = context.clone();
|
|
Arc::new({
|
|
move |ctx| {
|
|
context.draw_children(ctx);
|
|
}
|
|
})
|
|
}
|
|
}
|