wallet: beef up trace logging info on property output and dependencies when modified

bin/darkwallet/src/gfx/mod.rs

@@ -51,7 +51,6 @@ use crate::{
 // This is very noisy so suppress output by default
 const DEBUG_RENDER: bool = false;
 const DEBUG_GFXAPI: bool = false;
-const DEBUG_RSRC: bool = false;
 
 #[cfg(target_os = "android")]
 pub fn get_window_size_filename() -> PathBuf {
@@ -96,9 +95,6 @@ pub struct ManagedTexture {
 
 impl Drop for ManagedTexture {
     fn drop(&mut self) {
-        if DEBUG_RSRC {
-            debug!(target: "gfx", "Dropping texture ID={}", self.id);
-        }
         self.render_api.delete_unmanaged_texture(self.id);
     }
 }
@@ -246,9 +242,7 @@ impl GfxDrawMesh {
                 error!(target: "gfx", "{gfx_texture_id} => {texture_id:?}");
             }
 
-            if DEBUG_RSRC {
-                panic!("Missing texture ID={gfx_texture_id}");
-            }
+            panic!("Missing texture ID={gfx_texture_id}");
             return None
         };
 
@@ -266,9 +260,7 @@ impl GfxDrawMesh {
                 error!(target: "gfx", "{gfx_buffer_id} => {buffer_id:?}");
             }
 
-            if DEBUG_RSRC {
-                panic!("Missing buffer ID={gfx_buffer_id}");
-            }
+            panic!("Missing buffer ID={gfx_buffer_id}");
             return None
         };
         Some(*mq_buffer_id)
@@ -772,22 +764,20 @@ impl Stage {
                 error!(target: "gfx", "fatal: replace_draw_calls({timest}, ...) failed with item ID={key}");
                 continue
             };
-            self.draw_calls.insert(key, val);
-            /*
+            //self.draw_calls.insert(key, val);
             match self.draw_calls.get_mut(&key) {
                 Some(old_val) => {
                     // Only replace the draw call if it is more recent
                     if old_val.timest < timest {
                         *old_val = val;
-                    } else if DEBUG_RSRC {
-                        debug!(target: "gfx", "Rejected stale draw_call {key}: {val:?}");
+                    } else {
+                        trace!(target: "gfx", "Rejected stale draw_call {key}: {val:?}");
                     }
                 }
                 None => {
                     self.draw_calls.insert(key, val);
                 }
             }
-            */
         }
     }
 }

bin/darkwallet/src/plugin/darkirc.rs

@@ -444,15 +444,13 @@ impl PluginObject for DarkIrc {
         let me = Arc::downgrade(&self);
 
         let node = &self.node.upgrade().unwrap();
-        let node_name = node.name.clone();
-        let node_id = node.id;
 
         let method_sub = node.subscribe_method_call("send").unwrap();
         let me2 = me.clone();
         let send_method_task =
             ex.spawn(async move { while Self::process_send(&me2, &method_sub).await {} });
 
-        let mut on_modify = OnModify::new(ex.clone(), node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex.clone(), self.node.clone(), me.clone());
         async fn save_nick(self_: Arc<DarkIrc>) {
             let _ = std::fs::write(nick_filename(), self_.nick.get());
         }

bin/darkwallet/src/prop/mod.rs

@@ -27,7 +27,7 @@ use std::{
 use crate::{
     expr::SExprCode,
     pubsub::{Publisher, PublisherPtr, Subscription},
-    scene::SceneNodeId,
+    scene::{SceneNodeId, SceneNodeWeak},
 };
 
 mod wrap;
@@ -211,9 +211,9 @@ pub struct PropertyDepend {
     pub local_name: String,
 }
 
-#[derive(Debug)]
 pub struct Property {
     pub name: String,
+    pub node: SyncMutex<Option<SceneNodeWeak>>,
     pub typ: PropertyType,
     pub subtype: PropertySubType,
     pub defaults: Vec<PropertyValue>,
@@ -244,6 +244,7 @@ impl Property {
     pub fn new<S: Into<String>>(name: S, typ: PropertyType, subtype: PropertySubType) -> Self {
         Self {
             name: name.into(),
+            node: SyncMutex::new(None),
             typ,
             subtype,
 
@@ -267,6 +268,11 @@ impl Property {
         }
     }
 
+    /// Just used for debugging
+    pub fn set_parent(&self, node: SceneNodeWeak) {
+        *self.node.lock().unwrap() = Some(node);
+    }
+
     pub fn set_ui_text<S: Into<String>>(&mut self, ui_name: S, desc: S) {
         self.ui_name = ui_name.into();
         self.desc = desc.into();
@@ -705,6 +711,19 @@ impl Property {
     }
 }
 
+impl std::fmt::Debug for Property {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let node = {
+            let mut null_name = || write!(f, "<null>:{}", self.name);
+            let Ok(node) = self.node.lock() else { return null_name() };
+            let Some(node) = node.clone() else { return null_name() };
+            let Some(node) = node.upgrade() else { return null_name() };
+            node
+        };
+        write!(f, "{:?}:{}", node, self.name)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

bin/darkwallet/src/scene.rs

@@ -160,6 +160,12 @@ impl SceneNode {
     {
         let mut self_ = Arc::new(self);
         let weak_self = Arc::downgrade(&self_);
+
+        // Initial props
+        for prop in &self_.props {
+            prop.set_parent(weak_self.clone());
+        }
+
         let pimpl = pimpl_fn(weak_self).await;
         // Arc::new_cyclic() doesnt allow async so we do this instead
         unsafe {

bin/darkwallet/src/ui/chatedit.rs

@@ -1845,8 +1845,6 @@ impl UIObject for ChatEdit {
         let me = Arc::downgrade(&self);
 
         let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
 
         let method_sub = node_ref.subscribe_method_call("insert_text").unwrap();
         let me2 = me.clone();
@@ -1855,7 +1853,7 @@ impl UIObject for ChatEdit {
                 async move { while Self::process_insert_text_method(&me2, &method_sub).await {} },
             );
 
-        let mut on_modify = OnModify::new(ex.clone(), node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex.clone(), self.node.clone(), me.clone());
         on_modify.when_change(self.is_focused.prop(), Self::change_focus);
 
         // When text has been changed.

bin/darkwallet/src/ui/chatview/mod.rs

@@ -724,8 +724,6 @@ impl UIObject for ChatView {
         let me = Arc::downgrade(&self);
 
         let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
 
         let method_sub = node_ref.subscribe_method_call("insert_line").unwrap();
         let me2 = me.clone();
@@ -768,7 +766,7 @@ impl UIObject for ChatView {
             }
         });
 
-        let mut on_modify = OnModify::new(ex, node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex, self.node.clone(), me.clone());
 
         async fn reload_view(self_: Arc<ChatView>) {
             self_.scrollview(self_.scroll.get()).await;

bin/darkwallet/src/ui/editbox/mod.rs

@@ -1266,11 +1266,7 @@ impl UIObject for EditBox {
     async fn start(self: Arc<Self>, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
-        let mut on_modify = OnModify::new(ex.clone(), node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex.clone(), self.node.clone(), me.clone());
         on_modify.when_change(self.is_focused.prop(), Self::change_focus);
 
         // When text has been changed.

bin/darkwallet/src/ui/emoji_picker/mod.rs

@@ -319,15 +319,11 @@ impl UIObject for EmojiPicker {
     async fn start(self: Arc<Self>, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
         async fn redraw(self_: Arc<EmojiPicker>) {
             self_.redraw();
         }
 
-        let mut on_modify = OnModify::new(ex, node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex, self.node.clone(), me.clone());
         on_modify.when_change(self.rect.prop(), redraw);
         on_modify.when_change(self.z_index.prop(), redraw);
 

bin/darkwallet/src/ui/image.rs

@@ -193,11 +193,7 @@ impl UIObject for Image {
     async fn start(self: Arc<Self>, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
-        let mut on_modify = OnModify::new(ex, node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex, self.node.clone(), me.clone());
         on_modify.when_change(self.rect.prop(), Self::redraw);
         on_modify.when_change(self.uv.prop(), Self::redraw);
         on_modify.when_change(self.z_index.prop(), Self::redraw);

bin/darkwallet/src/ui/layer.rs

@@ -145,11 +145,7 @@ impl UIObject for Layer {
     async fn start(self: Arc<Self>, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
-        let mut on_modify = OnModify::new(ex.clone(), node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex.clone(), self.node.clone(), me.clone());
         on_modify.when_change(self.is_visible.prop(), Self::redraw);
         on_modify.when_change(self.rect.prop(), Self::redraw);
         on_modify.when_change(self.z_index.prop(), Self::redraw);

bin/darkwallet/src/ui/mod.rs

@@ -18,15 +18,19 @@
 
 use async_trait::async_trait;
 use futures::stream::{FuturesUnordered, StreamExt};
+use log::{log_enabled, Level::Trace};
 use miniquad::{KeyCode, KeyMods, MouseButton, TouchPhase};
-use std::sync::{Arc, Weak};
+use std::{
+    fmt::Debug,
+    sync::{Arc, Weak},
+};
 
 use crate::{
     error::{Error, Result},
     expr::{SExprMachine, SExprVal},
     gfx::{GfxBufferId, GfxDrawCall, GfxDrawMesh, GfxTextureId, Point, Rectangle},
     prop::{ModifyAction, PropertyPtr, Role},
-    scene::{Pimpl, SceneNode as SceneNode3, SceneNodeId, SceneNodePtr},
+    scene::{Pimpl, SceneNode as SceneNode3, SceneNodeId, SceneNodePtr, SceneNodeWeak},
     ExecutorPtr,
 };
 
@@ -56,6 +60,9 @@ pub use text::{Text, TextPtr};
 mod win;
 pub use win::{Window, WindowPtr};
 
+macro_rules! e { ($($arg:tt)*) => { error!(target: "scene::on_modify", $($arg)*); } }
+macro_rules! t { ($($arg:tt)*) => { trace!(target: "scene::on_modify", $($arg)*); } }
+
 #[async_trait]
 pub trait UIObject: Sync {
     fn priority(&self) -> u32;
@@ -107,45 +114,41 @@ pub struct DrawUpdate {
 
 pub struct OnModify<T> {
     ex: ExecutorPtr,
-    node_name: String,
-    node_id: SceneNodeId,
+    node: SceneNodeWeak,
     me: Weak<T>,
     pub tasks: Vec<smol::Task<()>>,
 }
 
 impl<T: Send + Sync + 'static> OnModify<T> {
-    pub fn new(ex: ExecutorPtr, node_name: String, node_id: SceneNodeId, me: Weak<T>) -> Self {
-        Self { ex, node_name, node_id, me, tasks: vec![] }
+    pub fn new(ex: ExecutorPtr, node: SceneNodeWeak, me: Weak<T>) -> Self {
+        Self { ex, node, me, tasks: vec![] }
     }
 
     pub fn when_change<F>(&mut self, prop: PropertyPtr, f: impl Fn(Arc<T>) -> F + Send + 'static)
     where
         F: std::future::Future<Output = ()> + Send + 'static,
     {
-        let node_name = self.node_name.clone();
-        let node_id = self.node_id;
-
-        let mut on_modify_subs = vec![(None, prop.subscribe_modify())];
+        let mut on_modify_subs = vec![(Arc::downgrade(&prop), None, prop.subscribe_modify())];
         for dep in prop.get_depends() {
             let Some(dep_prop) = dep.prop.upgrade() else { continue };
-            on_modify_subs.push((Some(dep.i), dep_prop.subscribe_modify()));
+            on_modify_subs.push((dep.prop, Some(dep.i), dep_prop.subscribe_modify()));
         }
 
-        let prop_name = prop.name.clone();
         let me = self.me.clone();
+        let node = self.node.clone();
         let task = self.ex.spawn(async move {
             loop {
                 let mut poll_queues = FuturesUnordered::new();
-                for (i, (prop_i, on_modify_sub)) in on_modify_subs.iter().enumerate() {
+                for (i, (prop_weak, prop_i, on_modify_sub)) in on_modify_subs.iter().enumerate() {
                     let recv = on_modify_sub.receive();
                     poll_queues.push(async move {
                         let (role, action) = recv.await.ok()?;
-                        Some((i, prop_i, role, action))
+                        Some((i, prop_weak, prop_i, role, action))
                     });
                 }
 
-                let Some(Some((idx, prop_i, role, action))) = poll_queues.next().await else {
-                    error!(target: "app", "Property '{}':{}/'{}' on_modify pipe is broken", node_name, node_id, prop_name);
+                let Some(Some((idx, prop_weak, prop_i, role, action))) = poll_queues.next().await else {
+                    e!("Property {:?} on_modify pipe is broken", prop);
                     return
                 };
 
@@ -161,14 +164,19 @@ impl<T: Send + Sync + 'static> OnModify<T> {
                     }
                 }
 
-                trace!(target: "app", "Property '{}':{}/'{}' modified", node_name, node_id, prop_name);
+                if (idx == 0) {
+                    t!("Property {:?} modified [depend_idx={idx}, role={role:?}]", prop);
+                } else {
+                    t!(
+                        "Property {:?} modified -> triggering {:?} [depend_idx={idx}, role={role:?}]",
+                        prop_weak.upgrade().unwrap(),
+                        prop
+                    );
+                }
 
                 let Some(self_) = me.upgrade() else {
                     // Should not happen
-                    panic!(
-                        "'{}':{}/'{}' self destroyed before modify_task was stopped!",
-                        node_name, node_id, prop_name
-                    );
+                    panic!("{:?} self destroyed before modify_task was stopped!", prop);
                 };
 
                 //debug!(target: "app", "property modified");

bin/darkwallet/src/ui/text.rs

@@ -208,11 +208,7 @@ impl UIObject for Text {
     async fn start(self: Arc<Self>, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
-        let mut on_modify = OnModify::new(ex, node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex, self.node.clone(), me.clone());
         on_modify.when_change(self.rect.prop(), Self::redraw);
         on_modify.when_change(self.z_index.prop(), Self::redraw);
         on_modify.when_change(self.text.prop(), Self::redraw);

bin/darkwallet/src/ui/vector_art/mod.rs

@@ -159,11 +159,7 @@ impl UIObject for VectorArt {
     async fn start(self: Arc<Self>, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
-        let mut on_modify = OnModify::new(ex, node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex, self.node.clone(), me.clone());
         on_modify.when_change(self.is_visible.prop(), Self::redraw);
         on_modify.when_change(self.rect.prop(), Self::redraw);
         on_modify.when_change(self.z_index.prop(), Self::redraw);

bin/darkwallet/src/ui/win.rs

@@ -68,10 +68,6 @@ impl Window {
     pub async fn start(self: Arc<Self>, event_pub: GraphicsEventPublisherPtr, ex: ExecutorPtr) {
         let me = Arc::downgrade(&self);
 
-        let node_ref = &self.node.upgrade().unwrap();
-        let node_name = node_ref.name.clone();
-        let node_id = node_ref.id;
-
         // Start a task monitoring for window resize events
         // which updates screen_size
         let ev_sub = event_pub.subscribe_resize();
@@ -139,7 +135,7 @@ impl Window {
             self_.draw().await;
         };
 
-        let mut on_modify = OnModify::new(ex.clone(), node_name, node_id, me.clone());
+        let mut on_modify = OnModify::new(ex.clone(), self.node.clone(), me.clone());
         on_modify.when_change(self.scale.prop(), redraw_fn);
 
         let mut tasks = vec![