wallet: rename RenderLayer to Layer

bin/darkwallet/gui/print_tree.py

@@ -25,16 +25,16 @@ def print_node_info(parent_id, indent):
                 child_type = "keyboard"
             case SceneNodeType.MOUSE:
                 child_type = "mouse"
-            case SceneNodeType.RENDER_LAYER:
-                child_type = "render_layer"
-            case SceneNodeType.RENDER_OBJECT:
-                child_type = "render_object"
-            case SceneNodeType.RENDER_VECTOR_ART:
-                child_type = "render_vector_art"
-            case SceneNodeType.RENDER_TEXT:
-                child_type = "render_text"
-            case SceneNodeType.RENDER_TEXTURE:
-                child_type = "render_texture"
+            case SceneNodeType.LAYER:
+                child_type = "layer"
+            case SceneNodeType.OBJECT:
+                child_type = "object"
+            case SceneNodeType.VECTOR_ART:
+                child_type = "vector_art"
+            case SceneNodeType.TEXT:
+                child_type = "text"
+            case SceneNodeType.TEXTURE:
+                child_type = "texture"
             case SceneNodeType.FONTS:
                 child_type = "fonts"
             case SceneNodeType.FONT:

bin/darkwallet/pydrk/api.py

@@ -49,11 +49,11 @@ class SceneNodeType:
     WINDOW_INPUT = 6
     KEYBOARD = 7
     MOUSE = 8
-    RENDER_LAYER = 3
-    RENDER_OBJECT = 4
-    RENDER_VECTOR_ART = 5
-    RENDER_TEXT = 9
-    RENDER_TEXTURE = 13
+    LAYER = 3
+    OBJECT = 4
+    VECTOR_ART = 5
+    TEXT = 9
+    TEXTURE = 13
     FONTS = 10
     FONT = 11
     PLUGINS = 14

bin/darkwallet/src/app/mod.rs

@@ -38,9 +38,7 @@ use crate::{
         SceneNodeType, Slot,
     },
     text::TextShaperPtr,
-    ui::{
-        chatview, Button, ChatView, EditBox, Image, RenderLayer, Stoppable, Text, VectorArt, Window,
-    },
+    ui::{chatview, Button, ChatView, EditBox, Image, Layer, Stoppable, Text, VectorArt, Window},
     ExecutorPtr,
 };
 
@@ -232,7 +230,7 @@ impl App {
         }
         match &node.pimpl {
             Pimpl::Window(win) => win.stop().await,
-            Pimpl::RenderLayer(layer) => layer.stop().await,
+            Pimpl::Layer(layer) => layer.stop().await,
             Pimpl::VectorArt(svg) => svg.stop().await,
             Pimpl::Text(txt) => txt.stop().await,
             Pimpl::EditBox(ebox) => ebox.stop().await,

bin/darkwallet/src/app/node.rs

@@ -27,15 +27,13 @@ use crate::{
         SceneNodeType, Slot,
     },
     text::TextShaperPtr,
-    ui::{
-        chatview, Button, ChatView, EditBox, Image, RenderLayer, Stoppable, Text, VectorArt, Window,
-    },
+    ui::{chatview, Button, ChatView, EditBox, Image, Layer, Stoppable, Text, VectorArt, Window},
     ExecutorPtr,
 };
 
 pub fn create_layer(sg: &mut SceneGraph, name: &str) -> SceneNodeId {
     debug!(target: "app", "create_layer({name})");
-    let node = sg.add_node(name, SceneNodeType::RenderLayer);
+    let node = sg.add_node(name, SceneNodeType::Layer);
     let prop = Property::new("is_visible", PropertyType::Bool, PropertySubType::Null);
     node.add_property(prop).unwrap();
 
@@ -52,7 +50,7 @@ pub fn create_layer(sg: &mut SceneGraph, name: &str) -> SceneNodeId {
 
 pub fn create_vector_art(sg: &mut SceneGraph, name: &str) -> SceneNodeId {
     debug!(target: "app", "create_vector_art({name})");
-    let node = sg.add_node(name, SceneNodeType::RenderVectorArt);
+    let node = sg.add_node(name, SceneNodeType::VectorArt);
 
     let mut prop = Property::new("rect", PropertyType::Float32, PropertySubType::Pixel);
     prop.set_array_len(4);
@@ -106,7 +104,7 @@ pub fn create_image(sg: &mut SceneGraph, name: &str) -> SceneNodeId {
 
 pub fn create_text(sg: &mut SceneGraph, name: &str) -> SceneNodeId {
     debug!(target: "app", "create_text({name})");
-    let node = sg.add_node(name, SceneNodeType::RenderText);
+    let node = sg.add_node(name, SceneNodeType::Text);
 
     let mut prop = Property::new("rect", PropertyType::Float32, PropertySubType::Pixel);
     prop.set_array_len(4);

bin/darkwallet/src/app/schema.rs

@@ -31,7 +31,7 @@ use crate::{
     },
     text::TextShaperPtr,
     ui::{
-        chatview, vector_art::shape, Button, ChatView, EditBox, Image, RenderLayer, ShapeVertex,
+        chatview, vector_art::shape, Button, ChatView, EditBox, Image, Layer, ShapeVertex,
         Stoppable, Text, VectorArt, VectorShape, Window,
     },
     ExecutorPtr,
@@ -102,8 +102,7 @@ pub(super) async fn make_old(app: &App) {
     // Setup the pimpl
     let node_id = node.id;
     drop(sg);
-    let pimpl =
-        RenderLayer::new(app.ex.clone(), app.sg.clone(), node_id, app.render_api.clone()).await;
+    let pimpl = Layer::new(app.ex.clone(), app.sg.clone(), node_id, app.render_api.clone()).await;
     let mut sg = app.sg.lock().await;
     let node = sg.get_node_mut(node_id).unwrap();
     node.pimpl = pimpl;
@@ -551,8 +550,7 @@ pub(super) async fn make(app: &App) {
 
     let node_id = node.id;
     drop(sg);
-    let pimpl =
-        RenderLayer::new(app.ex.clone(), app.sg.clone(), node_id, app.render_api.clone()).await;
+    let pimpl = Layer::new(app.ex.clone(), app.sg.clone(), node_id, app.render_api.clone()).await;
     let mut sg = app.sg.lock().await;
     let node = sg.get_node_mut(node_id).unwrap();
     node.pimpl = pimpl;

bin/darkwallet/src/scene.rs

@@ -39,11 +39,11 @@ pub enum SceneNodeType {
     WindowInput = 6,
     Keyboard = 7,
     Mouse = 8,
-    RenderLayer = 3,
-    RenderObject = 4,
-    RenderVectorArt = 5,
-    RenderText = 9,
-    RenderTexture = 13,
+    Layer = 3,
+    Object = 4,
+    VectorArt = 5,
+    Text = 9,
+    Texture = 13,
     Fonts = 10,
     Font = 11,
     Plugins = 14,
@@ -661,7 +661,7 @@ pub struct Method {
 pub enum Pimpl {
     Null,
     Window(ui::WindowPtr),
-    RenderLayer(ui::RenderLayerPtr),
+    Layer(ui::LayerPtr),
     VectorArt(ui::VectorArtPtr),
     Text(ui::TextPtr),
     EditBox(ui::EditBoxPtr),

bin/darkwallet/src/ui/layer.rs

@@ -34,12 +34,12 @@ use super::{
     OnModify, Stoppable, UIObject,
 };
 
-pub type RenderLayerPtr = Arc<RenderLayer>;
+pub type LayerPtr = Arc<Layer>;
 
-pub struct RenderLayer {
+pub struct Layer {
     sg: SceneGraphPtr2,
     node_id: SceneNodeId,
-    // Task is dropped at the end of the scope for RenderLayer, hence ending it
+    // Task is dropped at the end of the scope for Layer, hence ending it
     #[allow(dead_code)]
     tasks: Vec<smol::Task<()>>,
     render_api: RenderApiPtr,
@@ -51,7 +51,7 @@ pub struct RenderLayer {
     z_index: PropertyUint32,
 }
 
-impl RenderLayer {
+impl Layer {
     pub async fn new(
         ex: ExecutorPtr,
         sg_ptr: SceneGraphPtr2,
@@ -62,9 +62,9 @@ impl RenderLayer {
         let node = sg.get_node(node_id).unwrap();
         let node_name = node.name.clone();
 
-        let is_visible = PropertyBool::wrap(node, Role::Internal, "is_visible", 0)
-            .expect("RenderLayer::is_visible");
-        let rect = node.get_property("rect").expect("RenderLayer::rect");
+        let is_visible =
+            PropertyBool::wrap(node, Role::Internal, "is_visible", 0).expect("Layer::is_visible");
+        let rect = node.get_property("rect").expect("Layer::rect");
         let z_index = PropertyUint32::wrap(node, Role::Internal, "z_index", 0).unwrap();
         drop(sg);
 
@@ -84,7 +84,7 @@ impl RenderLayer {
             }
         });
 
-        Pimpl::RenderLayer(self_)
+        Pimpl::Layer(self_)
     }
 
     pub async fn handle_char(
@@ -106,7 +106,7 @@ impl RenderLayer {
         };
 
         let Some(draw_update) = self.draw(&sg, &parent_rect).await else {
-            error!(target: "ui::layer", "RenderLayer {:?} failed to draw", node);
+            error!(target: "ui::layer", "Layer {:?} failed to draw", node);
             return;
         };
         self.render_api.replace_draw_calls(draw_update.draw_calls);
@@ -114,19 +114,19 @@ impl RenderLayer {
     }
 }
 
-impl Stoppable for RenderLayer {
+impl Stoppable for Layer {
     async fn stop(&self) {}
 }
 
 #[async_trait]
-impl UIObject for RenderLayer {
+impl UIObject for Layer {
     fn z_index(&self) -> u32 {
         self.z_index.get()
     }
 
     //#[async_recursion]
     async fn draw(&self, sg: &SceneGraph, parent_rect: &Rectangle) -> Option<DrawUpdate> {
-        debug!(target: "ui::layer", "RenderLayer::draw()");
+        debug!(target: "ui::layer", "Layer::draw()");
         let node = sg.get_node(self.node_id).unwrap();
 
         if !self.is_visible.get() {

bin/darkwallet/src/ui/mod.rs

@@ -43,7 +43,7 @@ pub use vector_art::{
     VectorArt, VectorArtPtr,
 };
 mod layer;
-pub use layer::{RenderLayer, RenderLayerPtr};
+pub use layer::{Layer, LayerPtr};
 mod text;
 pub use text::{Text, TextPtr};
 mod win;
@@ -217,11 +217,11 @@ pub fn read_rect(rect_prop: PropertyPtr) -> Result<Rectangle> {
 pub fn get_parent_rect(sg: &SceneGraph, node: &SceneNode) -> Option<Rectangle> {
     // read our parent
     if node.parents.is_empty() {
-        info!("RenderLayer {:?} has no parents so skipping", node);
+        info!("Layer {:?} has no parents so skipping", node);
         return None
     }
     if node.parents.len() != 1 {
-        error!("RenderLayer {:?} has too many parents so skipping", node);
+        error!("Layer {:?} has too many parents so skipping", node);
         return None
     }
     let parent_id = node.parents[0].id;
@@ -230,7 +230,7 @@ pub fn get_parent_rect(sg: &SceneGraph, node: &SceneNode) -> Option<Rectangle> {
         SceneNodeType::Window => {
             let Some(screen_size_prop) = parent_node.get_property("screen_size") else {
                 error!(
-                    "RenderLayer {:?} parent node {:?} missing screen_size property",
+                    "Window {:?} parent node {:?} missing screen_size property",
                     node, parent_node
                 );
                 return None
@@ -241,28 +241,22 @@ pub fn get_parent_rect(sg: &SceneGraph, node: &SceneNode) -> Option<Rectangle> {
             let parent_rect = Rectangle::from_array([0., 0., screen_width, screen_height]);
             parent_rect
         }
-        SceneNodeType::RenderLayer => {
+        SceneNodeType::Layer => {
             // get their rect property
             let Some(parent_rect) = parent_node.get_property("rect") else {
-                error!(
-                    "RenderLayer {:?} parent node {:?} missing rect property",
-                    node, parent_node
-                );
+                error!("Layer {:?} parent node {:?} missing rect property", node, parent_node);
                 return None
             };
             // read parent's rect
             let Ok(parent_rect) = read_rect(parent_rect) else {
-                error!(
-                    "RenderLayer {:?} parent node {:?} malformed rect property",
-                    node, parent_node
-                );
+                error!("Layer {:?} parent node {:?} malformed rect property", node, parent_node);
                 return None
             };
             parent_rect
         }
         _ => {
             error!(
-                "RenderLayer {:?} parent node {:?} wrong type {:?}",
+                "Layer {:?} parent node {:?} wrong type {:?}",
                 node, parent_node, parent_node.typ
             );
             return None
@@ -273,7 +267,7 @@ pub fn get_parent_rect(sg: &SceneGraph, node: &SceneNode) -> Option<Rectangle> {
 
 pub fn get_ui_object<'a>(node: &'a SceneNode) -> &'a dyn UIObject {
     match &node.pimpl {
-        Pimpl::RenderLayer(layer) => layer.as_ref(),
+        Pimpl::Layer(layer) => layer.as_ref(),
         Pimpl::VectorArt(svg) => svg.as_ref(),
         Pimpl::Text(txt) => txt.as_ref(),
         Pimpl::EditBox(editb) => editb.as_ref(),