wallet: update Button UI object to new backends

bin/darkwallet/src/app/mod.rs

@@ -222,7 +222,7 @@ impl App {
             })
             .await;
         self.sg_root.link(window.clone());
-        schema::make(&self, window).await;
+        schema::make_test(&self, window).await;
 
         debug!(target: "app", "Schema loaded");
 

bin/darkwallet/src/app/schema.rs

@@ -26,14 +26,15 @@ use crate::{
     prop::{
         Property, PropertyBool, PropertyFloat32, PropertyStr, PropertySubType, PropertyType, Role,
     },
-    scene::SceneNodePtr,
+    scene::{SceneNodePtr, Slot},
     text::TextShaperPtr,
     ui::{
+        //chatview, vector_art::shape, Button, ChatView, EditBox, Image, Layer, ShapeVertex,
+        //Stoppable, Text, VectorArt, VectorShape, Window,
+        Button,
         Image,
         Layer,
         ShapeVertex,
-        //chatview, vector_art::shape, Button, ChatView, EditBox, Image, Layer, ShapeVertex,
-        //Stoppable, Text, VectorArt, VectorShape, Window,
         Text,
         VectorArt,
         VectorShape,
@@ -156,11 +157,8 @@ pub(super) async fn make_test(app: &App, window: SceneNodePtr) {
         node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
-    /*
     // Create the button
-    let node_id = create_button(&mut sg, "btn");
-
-    let node = sg.get_node_mut(node_id).unwrap();
+    let node = create_button("btn");
     node.set_property_bool(Role::App, "is_active", true).unwrap();
     let prop = node.get_property("rect").unwrap();
     let code = cc.compile("w - 220").unwrap();
@@ -169,18 +167,12 @@ pub(super) async fn make_test(app: &App, window: SceneNodePtr) {
     prop.set_f32(Role::App, 2, 200.).unwrap();
     prop.set_f32(Role::App, 3, 60.).unwrap();
 
-    let (sender, btn_click_recvr) = async_channel::unbounded();
-    let slot_click = Slot { name: "button_clicked".to_string(), notify: sender };
-    node.register("click", slot_click).unwrap();
+    //let (sender, btn_click_recvr) = async_channel::unbounded();
+    //let slot_click = Slot { name: "button_clicked".to_string(), notify: sender };
+    //node.register("click", slot_click).unwrap();
 
-    drop(sg);
-    let pimpl = Button::new(app.ex.clone(), app.sg.clone(), node_id, app.event_pub.clone()).await;
-    let mut sg = app.sg.lock().await;
-    let node = sg.get_node_mut(node_id).unwrap();
-    node.pimpl = pimpl;
-
-    sg.link(node_id, layer_node_id).unwrap();
-    */
+    let node = node.setup(|me| Button::new(me, app.event_pub.clone(), app.ex.clone())).await;
+    layer_node.link(node);
 
     // Create another mesh
     let node = create_vector_art("box");

bin/darkwallet/src/scene.rs

@@ -353,5 +353,5 @@ pub enum Pimpl {
     //EditBox(ui::EditBoxPtr),
     //ChatView(ui::ChatViewPtr),
     Image(ui::ImagePtr),
-    //Button(ui::ButtonPtr),
+    Button(ui::ButtonPtr),
 }

bin/darkwallet/src/ui/button.rs

@@ -27,7 +27,7 @@ use crate::{
     gfx::{GraphicsEventPublisherPtr, Point, Rectangle},
     prop::{PropertyBool, PropertyPtr, PropertyRect, PropertyUint32, Role},
     pubsub::Subscription,
-    scene::{Pimpl, SceneGraph, SceneGraphPtr2, SceneNodeId},
+    scene::{Pimpl, SceneNodePtr, SceneNodeWeak},
     ExecutorPtr,
 };
 
@@ -36,8 +36,7 @@ use super::{DrawUpdate, UIObject};
 pub type ButtonPtr = Arc<Button>;
 
 pub struct Button {
-    node_id: SceneNodeId,
-    sg: SceneGraphPtr2,
+    node: SceneNodeWeak,
 
     is_active: PropertyBool,
     rect: PropertyRect,
@@ -48,23 +47,19 @@ pub struct Button {
 
 impl Button {
     pub async fn new(
-        ex: ExecutorPtr,
-        sg: SceneGraphPtr2,
-        node_id: SceneNodeId,
+        node: SceneNodeWeak,
         event_pub: GraphicsEventPublisherPtr,
+        ex: ExecutorPtr,
     ) -> Pimpl {
-        let scene_graph = sg.lock().await;
-        let node = scene_graph.get_node(node_id).unwrap();
-        //let node_name = node.name.clone();
-        let is_active = PropertyBool::wrap(node, Role::Internal, "is_active", 0).unwrap();
-        let rect = PropertyRect::wrap(node, Role::Internal, "rect").unwrap();
-        let z_index = PropertyUint32::wrap(node, Role::Internal, "z_index", 0).unwrap();
-        //let sig = node.get_signal("click").expect("Button::click");
-        drop(scene_graph);
+        debug!(target: "ui::button", "Button::new()");
+
+        let node_ref = &node.upgrade().unwrap();
+        let is_active = PropertyBool::wrap(node_ref, Role::Internal, "is_active", 0).unwrap();
+        let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
+        let z_index = PropertyUint32::wrap(node_ref, Role::Internal, "z_index", 0).unwrap();
 
         let self_ = Arc::new_cyclic(|me: &Weak<Self>| Self {
-            node_id,
-            sg,
+            node,
             is_active,
             rect,
             z_index,
@@ -81,17 +76,12 @@ impl UIObject for Button {
         self.z_index.get()
     }
 
-    async fn draw(&self, _: &SceneGraph, parent_rect: &Rectangle) -> Option<DrawUpdate> {
-        let _ = self.rect.eval(parent_rect);
+    async fn draw(&self, parent_rect: Rectangle) -> Option<DrawUpdate> {
+        let _ = self.rect.eval(&parent_rect);
         None
     }
 
-    async fn handle_mouse_btn_down(
-        &self,
-        sg: &SceneGraph,
-        btn: MouseButton,
-        mouse_pos: Point,
-    ) -> bool {
+    async fn handle_mouse_btn_down(&self, btn: MouseButton, mouse_pos: Point) -> bool {
         if !self.is_active.get() {
             return false
         }
@@ -109,12 +99,7 @@ impl UIObject for Button {
         true
     }
 
-    async fn handle_mouse_btn_up(
-        &self,
-        sg: &SceneGraph,
-        btn: MouseButton,
-        mouse_pos: Point,
-    ) -> bool {
+    async fn handle_mouse_btn_up(&self, btn: MouseButton, mouse_pos: Point) -> bool {
         if !self.is_active.get() {
             return false
         }
@@ -136,19 +121,13 @@ impl UIObject for Button {
         }
 
         debug!(target: "ui::button", "Mouse button clicked!");
-        let node = sg.get_node(self.node_id).unwrap();
-        node.trigger("click", vec![]).await.unwrap();
+        let node = self.node.upgrade().unwrap();
+        //node.trigger("click", vec![]).await.unwrap();
 
         true
     }
 
-    async fn handle_touch(
-        &self,
-        sg: &SceneGraph,
-        phase: TouchPhase,
-        id: u64,
-        touch_pos: Point,
-    ) -> bool {
+    async fn handle_touch(&self, phase: TouchPhase, id: u64, touch_pos: Point) -> bool {
         if !self.is_active.get() {
             return false
         }
@@ -166,15 +145,10 @@ impl UIObject for Button {
 
         // Simulate mouse events
         match phase {
-            TouchPhase::Started => {
-                self.handle_mouse_btn_down(sg, MouseButton::Left, touch_pos).await;
-            }
-            TouchPhase::Moved => {}
-            TouchPhase::Ended => {
-                self.handle_mouse_btn_up(sg, MouseButton::Left, touch_pos).await;
-            }
-            TouchPhase::Cancelled => {}
+            TouchPhase::Started => self.handle_mouse_btn_down(MouseButton::Left, touch_pos).await,
+            TouchPhase::Moved => false,
+            TouchPhase::Ended => self.handle_mouse_btn_up(MouseButton::Left, touch_pos).await,
+            TouchPhase::Cancelled => false,
         }
-        true
     }
 }

bin/darkwallet/src/ui/mod.rs

@@ -29,8 +29,8 @@ use crate::{
     ExecutorPtr,
 };
 
-//mod button;
-//pub use button::{Button, ButtonPtr};
+mod button;
+pub use button::{Button, ButtonPtr};
 //pub mod chatview;
 //pub use chatview::{ChatView, ChatViewPtr};
 //mod editbox;
@@ -149,7 +149,7 @@ pub fn get_ui_object3<'a>(node: &'a SceneNode3) -> &'a dyn UIObject {
         //Pimpl::EditBox(editb) => editb.as_ref(),
         //Pimpl::ChatView(chat) => chat.as_ref(),
         Pimpl::Image(obj) => obj.as_ref(),
-        //Pimpl::Button(btn) => btn.as_ref(),
+        Pimpl::Button(obj) => obj.as_ref(),
         _ => panic!("unhandled type for get_ui_object"),
     }
 }