app: cleanup and make some further fixes

bin/app/src/app/schema/chat.rs

@@ -29,7 +29,6 @@ use crate::{
         App,
     },
     expr::{self, Compiler},
-    gfx::make_render_guard,
     plugin::darkirc,
     prop::{
         Property, PropertyAtomicGuard, PropertyBool, PropertyFloat32, PropertyStr, PropertySubType,
@@ -292,15 +291,15 @@ pub async fn make(
     let render_api = app.render_api.clone();
     let goback = async move || {
         info!(target: "app::chat", "clicked back");
-        let mut atom = make_render_guard(&render_api);
+        let atom = &mut render_api.make_guard();
 
         let editz_node = layer_node2.clone().lookup_node("/content/editz").unwrap();
         editz_node.call_method("unfocus", vec![]).await.unwrap();
 
         let menu_node = sg_root.clone().lookup_node("/window/menu_layer").unwrap();
-        menu_node.set_property_bool(&mut atom, Role::App, "is_visible", true).unwrap();
+        menu_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
 
-        chatview_is_visible.set(&mut atom, false);
+        chatview_is_visible.set(atom, false);
     };
 
     let (slot, recvr) = Slot::new("back_clicked");
@@ -848,11 +847,11 @@ pub async fn make(
         let chatview_node = chatview_node.clone();
         let render_api = render_api.clone();
         async move {
-            let mut atom = make_render_guard(&render_api);
+            let atom = &mut render_api.make_guard();
 
             let mut text = editz_text.get();
             info!(target: "app::chat", "Send '{text}' to channel: {channel}");
-            editz_text.set(&mut atom, "");
+            editz_text.set(atom, "");
 
             let Some(darkirc) = sg_root.clone().lookup_node("/plugin/darkirc") else {
                 error!(target: "app::chat", "DarkIrc plugin has not been loaded");
@@ -862,7 +861,7 @@ pub async fn make(
             if text.starts_with("/nick") {
                 let nick = text.split_whitespace().nth(1).unwrap_or("anon");
                 info!(target: "app::chat", "Setting nick to: {nick}");
-                darkirc.set_property_str(&mut atom, Role::App, "nick", nick).unwrap();
+                darkirc.set_property_str(atom, Role::App, "nick", nick).unwrap();
 
                 let msg = format!("You are now known as <{nick}>");
                 let id: [u8; 32] = rand::random();
@@ -973,7 +972,7 @@ pub async fn make(
 
         while let Ok(_) = recvr.recv().await {
             info!(target: "app::chat", "clicked emoji");
-            let mut atom = make_render_guard(&render_api);
+            let atom = &mut render_api.make_guard();
 
             if cfg!(target_os = "android") {
                 let keyb_height = android_keyboard_height();
@@ -987,9 +986,9 @@ pub async fn make(
 
                 assert!(!emoji_close_is_visible.get());
                 assert!(emoji_h_prop.get() < 0.001);
-                emoji_btn_is_visible.set(&mut atom, false);
-                emoji_close_is_visible.set(&mut atom, true);
-                emoji_h_prop.set(&mut atom, panel_height as f32);
+                emoji_btn_is_visible.set(atom, false);
+                emoji_close_is_visible.set(atom, true);
+                emoji_h_prop.set(atom, panel_height as f32);
                 //for i in 1..=20 {
                 //    emoji_h_prop.set(&mut atom, (20 * i) as f32);
                 //    msleep(10).await;
@@ -999,9 +998,9 @@ pub async fn make(
 
                 assert!(emoji_close_is_visible.get());
                 assert!(emoji_h_prop.get() > 0.);
-                emoji_btn_is_visible.set(&mut atom, true);
-                emoji_close_is_visible.set(&mut atom, false);
-                emoji_h_prop.set(&mut atom, 0. as f32);
+                emoji_btn_is_visible.set(atom, true);
+                emoji_close_is_visible.set(atom, false);
+                emoji_h_prop.set(atom, 0. as f32);
                 //for i in 1..=20 {
                 //    emoji_h_prop.set(&mut atom, (400 - 20 * i) as f32);
                 //    msleep(10).await;
@@ -1050,10 +1049,10 @@ pub async fn make(
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             info!(target: "app::chat", "clicked /nick");
-            let mut atom = make_render_guard(&render_api);
+            let atom = &mut render_api.make_guard();
             // This will autohide this popup due to ending in a space.
             // Setting the property will retrigger the logic whether to show popup.
-            editz_text2.set(&mut atom, "/nick ");
+            editz_text2.set(atom, "/nick ");
         }
     });
     app.tasks.lock().unwrap().push(listen_click);
@@ -1316,8 +1315,8 @@ pub async fn make(
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             info!(target: "app::chat", "clicked copy");
-            let mut atom = make_render_guard(&render_api);
-            actions_is_visible2.set(&mut atom, false);
+            let atom = &mut render_api.make_guard();
+            actions_is_visible2.set(atom, false);
             let select_text = editz_select_text2.get_str(0).unwrap();
             miniquad::window::clipboard_set(&select_text);
         }
@@ -1343,7 +1342,7 @@ pub async fn make(
     let render_api = app.render_api.clone();
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
-            let mut atom = make_render_guard(&render_api);
+            let atom = &mut render_api.make_guard();
             if let Some(text) = miniquad::window::clipboard_get() {
                 info!(target: "app::chat", "clicked paste: {text}");
                 let mut data = vec![];
@@ -1352,7 +1351,7 @@ pub async fn make(
             } else {
                 info!(target: "app::chat", "clicked paste but clip is empty");
             }
-            actions_is_visible2.set(&mut atom, false);
+            actions_is_visible2.set(atom, false);
         }
     });
     app.tasks.lock().unwrap().push(listen_click);
@@ -1407,8 +1406,8 @@ pub async fn make(
     let render_api = app.render_api.clone();
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
-            let mut atom = make_render_guard(&render_api);
-            pasta_is_visible2.set(&mut atom, true);
+            let atom = &mut render_api.make_guard();
+            pasta_is_visible2.set(atom, true);
         }
     });
     app.tasks.lock().unwrap().push(listen_click);
@@ -1493,7 +1492,7 @@ pub async fn make(
     let render_api = app.render_api.clone();
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
-            let mut atom = make_render_guard(&render_api);
+            let atom = &mut render_api.make_guard();
             if let Some(text) = miniquad::window::clipboard_get() {
                 info!(target: "app::chat", "clicked paste: {text}");
                 let mut data = vec![];
@@ -1502,7 +1501,7 @@ pub async fn make(
             } else {
                 info!(target: "app::chat", "clicked paste but clip is empty");
             }
-            pasta_is_visible2.set(&mut atom, false);
+            pasta_is_visible2.set(atom, false);
         }
     });
     app.tasks.lock().unwrap().push(listen_click);
@@ -1514,16 +1513,16 @@ pub async fn make(
         let render_api = app.render_api.clone();
         let editz_select_task = app.ex.spawn(async move {
             while let Ok(_) = editz_select_sub.receive().await {
-                let mut atom = make_render_guard(&render_api);
+                let atom = &mut render_api.make_guard();
                 if editz_select_text.is_null(0).unwrap() {
                     info!(target: "app::chat", "selection changed: null");
-                    actions_is_visible.set(&mut atom, false);
-                    pasta_is_visible2.set(&mut atom, false);
+                    actions_is_visible.set(atom, false);
+                    pasta_is_visible2.set(atom, false);
                 } else {
                     let select_text = editz_select_text.get_str(0).unwrap();
                     info!(target: "app::chat", "selection changed: {select_text}");
-                    actions_is_visible.set(&mut atom, true);
-                    pasta_is_visible2.set(&mut atom, false);
+                    actions_is_visible.set(atom, true);
+                    pasta_is_visible2.set(atom, false);
                 }
             }
         });
@@ -1534,8 +1533,8 @@ pub async fn make(
     let render_api = app.render_api.clone();
     let editz_text_task = app.ex.spawn(async move {
         while let Ok(_) = editz_text_sub.receive().await {
-            let mut atom = make_render_guard(&render_api);
-            pasta_is_visible.set(&mut atom, false);
+            let atom = &mut render_api.make_guard();
+            pasta_is_visible.set(atom, false);
 
             let text = editz_text.get();
             debug!(target: "app::chat", "text changed: {text}");
@@ -1545,11 +1544,11 @@ pub async fn make(
             // Only show popup for "/ni", "/nick", but not for: "", "/nick ", "/nick foo"
             if !text.is_empty() && "/nick".starts_with(&text) && text.len() <= "/nick".len() {
                 if !cmd_hint_is_visible.get() {
-                    cmd_hint_is_visible.set(&mut atom, true);
+                    cmd_hint_is_visible.set(atom, true);
                 }
             } else {
                 if cmd_hint_is_visible.get() {
-                    cmd_hint_is_visible.set(&mut atom, false);
+                    cmd_hint_is_visible.set(atom, false);
                 }
             }
         }

bin/app/src/app/schema/menu.rs

@@ -22,7 +22,6 @@ use crate::{
         App,
     },
     expr,
-    gfx::make_render_guard,
     prop::{PropertyAtomicGuard, PropertyBool, PropertyFloat32, Role},
     scene::{SceneNodePtr, Slot},
     ui::{Button, Layer, ShapeVertex, Shortcut, Text, VectorArt, VectorShape},
@@ -256,11 +255,11 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
         let render_api = app.render_api.clone();
         let select_channel = move || {
-            let mut atom = make_render_guard(&render_api);
+            let atom = &mut render_api.make_guard();
             info!(target: "app::menu", "clicked: {channel}!");
-            chatview_is_visible.set(&mut atom, true);
-            menu_is_visible.set(&mut atom, false);
-            set_normal_color(&mut atom);
+            chatview_is_visible.set(atom, true);
+            menu_is_visible.set(atom, false);
+            set_normal_color(atom);
         };
 
         let select_channel2 = select_channel.clone();

bin/app/src/app/schema/mod.rs

@@ -26,7 +26,6 @@ use crate::{
         App,
     },
     expr::{self, Compiler},
-    gfx::make_render_guard,
     prop::{PropertyAtomicGuard, Role},
     scene::{SceneNodePtr, Slot},
     shape,
@@ -154,8 +153,8 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 scale.encode(&mut file).unwrap();
             }
 
-            let mut atom = make_render_guard(&render_api);
-            window_scale2.set_property_f32(&mut atom, Role::User, "value", scale).unwrap();
+            let atom = &mut render_api.make_guard();
+            window_scale2.set_property_f32(atom, Role::User, "value", scale).unwrap();
         }
     });
     app.tasks.lock().unwrap().push(listen_zoom);
@@ -182,8 +181,8 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 scale.encode(&mut file).unwrap();
             }
 
-            let mut atom = make_render_guard(&render_api);
-            window_scale2.set_property_f32(&mut atom, Role::User, "value", scale).unwrap();
+            let atom = &mut render_api.make_guard();
+            window_scale2.set_property_f32(atom, Role::User, "value", scale).unwrap();
         }
     });
     app.tasks.lock().unwrap().push(listen_zoom);

bin/app/src/gfx/mod.rs

@@ -284,10 +284,6 @@ impl RenderApi {
     }
 }
 
-pub fn make_render_guard(render_api: &RenderApi) -> PropertyAtomicGuard {
-    render_api.make_guard()
-}
-
 #[derive(Clone, Debug)]
 pub struct GfxDrawMesh {
     pub vertex_buffer: ManagedBufferPtr,

bin/app/src/net.rs

@@ -24,8 +24,8 @@ use zeromq::{Socket, SocketRecv, SocketSend};
 use crate::{
     error::{Error, Result},
     expr::SExprCode,
-    gfx::{make_render_guard, RenderApi},
-    prop::{PropertyAtomicGuard, PropertyType, Role},
+    gfx::RenderApi,
+    prop::{PropertyType, Role},
     scene::{SceneNodeId, SceneNodePtr, ScenePath},
     ExecutorPtr,
 };
@@ -246,40 +246,40 @@ impl ZeroMQAdapter {
                     self.sg_root.clone().lookup_node(node_path).ok_or(Error::NodeNotFound)?;
                 let prop = node.get_property(&prop_name).ok_or(Error::PropertyNotFound)?;
 
-                let mut atom = make_render_guard(&self.render_api);
+                let atom = &mut self.render_api.make_guard();
 
                 match prop_type {
                     PropertyType::Null => {
-                        prop.set_null(&mut atom, Role::User, prop_i)?;
+                        prop.set_null(atom, Role::User, prop_i)?;
                     }
                     PropertyType::Bool => {
                         let val = bool::decode(&mut cur).unwrap();
-                        prop.set_bool(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_bool(atom, Role::User, prop_i, val)?;
                     }
                     PropertyType::Uint32 => {
                         let val = u32::decode(&mut cur).unwrap();
-                        prop.set_u32(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_u32(atom, Role::User, prop_i, val)?;
                     }
                     PropertyType::Float32 => {
                         let val = f32::decode(&mut cur).unwrap();
-                        prop.set_f32(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_f32(atom, Role::User, prop_i, val)?;
                     }
                     PropertyType::Str => {
                         let val = String::decode(&mut cur).unwrap();
-                        prop.set_str(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_str(atom, Role::User, prop_i, val)?;
                     }
                     PropertyType::Enum => {
                         let val = String::decode(&mut cur).unwrap();
-                        prop.set_enum(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_enum(atom, Role::User, prop_i, val)?;
                     }
                     PropertyType::SceneNodeId => {
                         let val = SceneNodeId::decode(&mut cur).unwrap();
-                        prop.set_node_id(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_node_id(atom, Role::User, prop_i, val)?;
                     }
                     PropertyType::SExpr => {
                         let val = SExprCode::decode(&mut cur).unwrap();
                         debug!(target: "req", "  received code {:?}", val);
-                        prop.set_expr(&mut atom, Role::User, prop_i, val)?;
+                        prop.set_expr(atom, Role::User, prop_i, val)?;
                     }
                 }
             }

bin/app/src/prop/guard.rs

@@ -59,6 +59,10 @@ impl PropertyAtomicGuard {
         Self { batch_id, updates: vec![], end_batch: Some(end_batch), parent: None }
     }
 
+    /// Should only be used when there's an explicit end_batch() called manually at the end
+    /// of the context.
+    /// You probably mostly want to either `batch.spawn()` from an existing batch
+    /// or use `render_api.make_guard()`.
     pub fn none() -> Self {
         Self::new(Box::new(|_| {}), Box::new(|_| {}))
     }

bin/app/src/ui/chatedit.rs

@@ -1292,6 +1292,7 @@ impl ChatEdit {
             return
         }
 
+        let atom = &mut self.render_api.make_guard();
         match ev {
             AndroidSuggestEvent::Init => {
                 let mut editor = self.lock_editor().await;
@@ -1318,7 +1319,6 @@ impl ChatEdit {
                 self.is_phone_select.store(false, Ordering::Relaxed);
                 self.hide_cursor.store(false, Ordering::Relaxed);
 
-                let atom = &mut PropertyAtomicGuard::new();
                 self.finish_select(atom);
 
                 let mut editor = self.lock_editor().await;
@@ -1332,7 +1332,7 @@ impl ChatEdit {
         // Only redraw once we have the parent_rect
         // Can happen when we receive an Android event before the canvas is ready
         if self.parent_rect.lock().is_some() {
-            self.redraw().await;
+            self.redraw(atom).await;
         }
     }
 }