mouse input

src/extensions/mod.rs

@@ -1,11 +1,14 @@
+pub mod mouse;
 pub mod tick;
 pub mod velocity;
 
 use std::sync::Arc;
 
-use crate::widget::Widget;
+use minifb::Window;
+
+use crate::{style::RawTransform, widget::Widget};
 
 pub trait Extension {
-    fn init(&self, _widgets: &Vec<Arc<Widget>>) {}
+    fn init(&mut self, _widgets: &Vec<Arc<Widget>>) {}
-    fn render(&self, _widget: &Arc<Widget>) {}
+    fn render(&mut self, _widgets: &Arc<Widget>, _transform: RawTransform, _win: &Window) {}
 }

src/extensions/mouse.rs

@@ -0,0 +1,44 @@
+use std::sync::Arc;
+
+use minifb::{MouseButton, Window};
+
+use crate::{component, extensions::Extension, style::RawTransform, widget::Widget};
+
+pub struct MouseExtension(bool);
+
+impl Extension for MouseExtension {
+    fn render(&mut self, widget: &Arc<Widget>, transform: RawTransform, win: &Window) {
+        if win.get_mouse_down(MouseButton::Left) {
+            if !self.0 {
+                self.0 = true;
+                if let Some((mx, my)) = win.get_mouse_pos(minifb::MouseMode::Discard) {
+                    let (mx, my) = (mx as usize, my as usize);
+                    if mx >= transform.x
+                        && my >= transform.y
+                        && mx <= transform.x + transform.width
+                        && mx <= transform.y + transform.height
+                    {
+                        std::thread::spawn({
+                            let widget = widget.clone();
+                            move || {
+                                if let Some(on_click) = widget.get::<OnClick>() {
+                                    (on_click.0)(&widget)
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        } else {
+            self.0 = false;
+        }
+    }
+}
+
+impl MouseExtension {
+    pub fn new() -> Self {
+        MouseExtension(false)
+    }
+}
+
+component!(OnClick(pub fn(&Arc<Widget>)));

src/extensions/tick.rs

@@ -5,7 +5,7 @@ use crate::{component, extensions::Extension, widget::Widget};
 pub struct TickExtension(pub usize);
 
 impl Extension for TickExtension {
-    fn init(&self, widgets: &Vec<Arc<Widget>>) {
+    fn init(&mut self, widgets: &Vec<Arc<Widget>>) {
         let rate_dur = 1000 / self.0 as u64;
         std::thread::spawn({
             let widgets = widgets.clone();

src/extensions/velocity.rs

@@ -42,7 +42,7 @@ impl VelocityExtension {
 }
 
 impl Extension for VelocityExtension {
-    fn init(&self, widgets: &Vec<Arc<Widget>>) {
+    fn init(&mut self, widgets: &Vec<Arc<Widget>>) {
         std::thread::spawn({
             let widgets = widgets.clone();
             move || {

src/lib.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use minifb::Window;
 
@@ -20,7 +20,7 @@ pub mod widget;
 pub struct Screen {
     window: Window,
     pub widgets: Vec<Arc<Widget>>,
-    extensions: Vec<Arc<Box<dyn Extension>>>,
+    extensions: Vec<Arc<Mutex<Box<dyn Extension>>>>,
 }
 
 impl Screen {
@@ -38,7 +38,7 @@ impl Screen {
     }
 
     pub fn extension<E: Extension + 'static>(&mut self, ext: E) {
-        self.extensions.push(Arc::new(Box::new(ext)));
+        self.extensions.push(Arc::new(Mutex::new(Box::new(ext))));
     }
 
     pub fn run(&mut self) -> std::io::Result<()> {
@@ -47,7 +47,7 @@ impl Screen {
         }
 
         for ext in &self.extensions {
-            ext.init(&self.widgets);
+            ext.lock().unwrap().init(&self.widgets);
         }
 
         while self.window.is_open() {
@@ -68,13 +68,18 @@ impl Screen {
                 scope.set_transform(&t);
             }
 
-            self.render_extension(elem.clone()).unwrap();
             elem.0.lock().unwrap().render(&mut scope);
 
             if let Some(t) = elem.get() {
                 scope.set_transform(&t);
             }
 
+            for ext in &self.extensions {
+                ext.lock()
+                    .unwrap()
+                    .render(elem, scope.get_transform(), &self.window);
+            }
+
             scope.draw();
         }
 
@@ -82,11 +87,4 @@ impl Screen {
             .update_with_buffer(&scope.get_buffer1d(), w, h)
             .unwrap();
     }
-
-    pub fn render_extension(&self, wi: Arc<Widget>) -> std::io::Result<()> {
-        for ext in &self.extensions {
-            ext.render(&wi);
-        }
-        Ok(())
-    }
 }

src/main.rs

@@ -1,6 +1,9 @@
 use minifb::{Window, WindowOptions};
 use osgui::{
-    elements::div::Div, extensions::velocity::VelocityExtension, style::Transform, Screen,
+    elements::div::Div,
+    extensions::{mouse::MouseExtension, velocity::VelocityExtension},
+    style::Transform,
+    Screen,
 };
 
 fn main() {
@@ -17,6 +20,7 @@ fn main() {
 
     let mut app = Screen::new(window);
     app.extension(VelocityExtension);
+    app.extension(MouseExtension::new());
 
     let mut d = Div::new();
 

src/render.rs

@@ -147,6 +147,10 @@ impl RenderScope {
         transform.use_position(self.parent_width, self.parent_height, &mut self.transform);
     }
 
+    pub fn get_transform(&mut self) -> RawTransform {
+        self.transform.clone()
+    }
+
     pub fn update_size(&mut self) {
         self.max_size.0 = self.max_size.0.max(self.transform.width);
         self.max_size.1 = self.max_size.1.max(self.transform.height);