Multithreaded

examples/hello_world.rs

@@ -5,10 +5,19 @@ use osui::prelude::*;
 fn main() {
     let mut cx = Context::new(app);
     cx.refresh();
-    println!("{:?}", cx.get_nodes());
+
+    std::thread::spawn({
+        let cx = cx.clone();
+        move || {}
+    });
+
+    loop {
+        println!("{:?}", cx.get_nodes());
+        std::thread::sleep(std::time::Duration::from_millis(16));
+    }
 }
 
-fn app(cx: &mut Context) -> Vec<Node> {
+fn app(cx: &Arc<Context>) -> Vec<Node> {
     let count = use_state(0);
 
     vec![Node::String(Arc::new(move || format!("{count}")))]

src/component.rs

@@ -1,27 +1,28 @@
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use crate::Node;
 
-pub type Component = Arc<dyn Fn(&mut Context) -> Vec<Node>>;
+pub type Component = Arc<dyn Fn(&Arc<Context>) -> Vec<Node>>;
 
 pub struct Context {
-    component: Component,
-    nodes: Vec<Node>,
+    component: Mutex<Component>,
+    nodes: Mutex<Vec<Node>>,
 }
 
 impl Context {
-    pub fn new<F: Fn(&mut Context) -> Vec<Node> + 'static>(component: F) -> Self {
-        Self {
-            component: Arc::new(component),
-            nodes: Vec::new(),
-        }
+    pub fn new<F: Fn(&Arc<Context>) -> Vec<Node> + 'static>(component: F) -> Arc<Self> {
+        Arc::new(Self {
+            component: Mutex::new(Arc::new(component)),
+            nodes: Mutex::new(Vec::new()),
+        })
     }
 
-    pub fn refresh(&mut self) {
-        self.nodes = (self.component.clone())(self);
+    pub fn refresh(self: &Arc<Context>) {
+        let c = self.component.lock().unwrap().clone();
+        *self.nodes.lock().unwrap() = (c)(self);
     }
 
-    pub fn get_nodes(&self) -> Vec<Node> {
-        self.nodes.clone()
+    pub fn get_nodes(self: &Arc<Context>) -> Vec<Node> {
+        self.nodes.lock().unwrap().clone()
     }
 }