semi working state management

src/dependency.rs

@@ -0,0 +1,58 @@
+use std::sync::Arc;
+
+use crate::{widget::Element};
+
+pub trait DependencyHandler: std::fmt::Debug + Send + Sync {
+    fn add(&self);
+    fn check(&self) -> bool;
+}
+
+pub struct Dependency<T: Element> {
+    handlers: Vec<std::sync::Arc<dyn DependencyHandler>>,
+    element: T,
+    element_reset: Box<dyn FnMut() -> T + Send + Sync>,
+}
+
+impl<T: Element> Dependency<T> {
+    pub fn new<F: FnMut() -> T + Send + Sync + 'static>(mut f: F) -> Self {
+        Self {
+            handlers: Vec::new(),
+            element: f(),
+            element_reset: Box::new(f),
+        }
+    }
+
+    pub fn auto_reset(&mut self) {
+        for i in &self.handlers {
+            if i.check() {
+                self.element = (self.element_reset)();
+            }
+        }
+    }
+
+    pub fn add<D: DependencyHandler + 'static>(mut self, dep: D) -> Self {
+        dep.add();
+        self.handlers.push(Arc::new(dep));
+        self
+    }
+}
+
+impl<T: Element + 'static> Element for Dependency<T> {
+    fn render(&mut self, scope: &mut crate::render_scope::RenderScope) {
+        self.element.render(scope);
+        self.auto_reset();
+    }
+
+    fn after_render(&mut self, scope: &crate::render_scope::RenderScope) {
+        self.element.after_render(scope);
+        self.auto_reset();
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+}

src/elements/state.rs

@@ -1,16 +1,20 @@
-use crate::{render_scope::RenderScope, widget::Element};
-use std::sync::{Arc, Mutex};
+use std::ops::{Deref, DerefMut};
 
+use crate::dependency::DependencyHandler;
+
+#[derive(Debug)]
 pub struct State<T> {
     pub value: *mut T,
-    dependents: Mutex<Vec<Arc<Mutex<StateDependency>>>>,
+    dependencies: *mut usize,
+    changed: *mut usize, // set to dependencies when the value is changed
 }
 
-pub fn use_state<T>(mut v: T) -> Arc<State<T>> {
-    Arc::new(State {
+pub fn use_state<T>(mut v: T) -> State<T> {
+    State {
         value: &mut v,
-        dependents: Mutex::new(Vec::new()),
-    })
+        dependencies: &mut 0,
+        changed: &mut 0,
+    }
 }
 
 impl<T> State<T> {
@@ -19,50 +23,72 @@ impl<T> State<T> {
             *self.value = v;
         }
 
-        for d in self.dependents.lock().unwrap().iter() {
-            let mut d = d.lock().unwrap();
-            d.0 = (d.1)();
+        self.change();
+    }
+
+    pub fn change(&self) {
+        unsafe {
+            *self.changed = *self.dependencies;
+        }
     }
 }
 
-    pub fn draw<F: FnMut() -> Box<dyn Element> + 'static + Send + Sync>(
-        self: &Arc<Self>,
-        mut element: F,
-    ) -> Arc<Mutex<StateDependency>> {
-        let d = Arc::new(Mutex::new(StateDependency((element)(), Box::new(element))));
-        self.dependents.lock().unwrap().push(d.clone());
-        d
+impl<T: std::fmt::Debug> DependencyHandler for State<T> {
+    fn check(&self) -> bool {
+        unsafe {
+            let i = *self.changed > 0;
+            if i {
+                *self.changed -= 1;
+            }
+            i
         }
     }
 
-pub struct StateDependency(
-    Box<dyn Element>,
-    pub Box<dyn FnMut() -> Box<dyn Element> + Send + Sync>,
-);
-
-impl<'a> Element for Arc<Mutex<StateDependency>> {
-    fn render(&mut self, scope: &mut RenderScope) {
-        self.lock().unwrap().0.render(scope);
+    fn add(&self) {
+        unsafe {
+            *self.dependencies += 1;
         }
-
-    fn after_render(&mut self, scope: &RenderScope) {
-        self.lock().unwrap().0.after_render(scope);
-    }
-
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
     }
 }
 
 impl<T: std::fmt::Display> std::fmt::Display for State<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        unsafe { &*self.value }.fmt(f)
+        write!(f, "{}", unsafe { &*self.value })
     }
 }
 
 unsafe impl<T> Send for State<T> {}
 unsafe impl<T> Sync for State<T> {}
+
+impl<T> Deref for State<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.value }
+    }
+}
+
+impl<T> DerefMut for State<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe {
+            self.change();
+
+            &mut *self.value
+        }
+    }
+}
+
+impl<T> Clone for State<T> {
+    fn clone(&self) -> Self {
+        Self {
+            value: self.value,
+            dependencies: self.dependencies,
+            changed: self.changed,
+        }
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.changed = source.changed;
+        self.dependencies = source.dependencies;
+        self.value = source.value;
+    }
+}

src/lib.rs

@@ -7,6 +7,7 @@ use crate::{
     widget::{Element, Widget},
 };
 
+pub mod dependency;
 pub mod elements;
 pub mod extensions;
 pub mod macros;

src/main.rs

@@ -1,17 +1,23 @@
-use osui::{elements::state::use_state, Screen};
+use osui::{dependency::Dependency, elements::state::use_state, style::Transform, Screen};
 
 fn main() -> std::io::Result<()> {
     let screen = Screen::new();
     let count = use_state(0);
 
-    screen.draw(count.draw({
+    screen
+        .draw(
+            Dependency::new({
                 let count = count.clone();
-        move || Box::new(format!("Count: {count}"))
-    }));
+                move || format!("{count}")
+            })
+            .add(count.clone()),
+        )
+        .component(Transform::center());
 
     std::thread::spawn(move || loop {
-        std::thread::sleep(std::time::Duration::from_millis(500));
-        count.set(unsafe { *count.value } + 1);
+        std::thread::sleep(std::time::Duration::from_millis(900));
+        let c = (*count).clone();
+        count.set(c + 1);
     });
 
     screen.run()