wallet: re-enable net backend with new scenegraph

bin/darkwallet/gui/print_tree.py

@@ -7,13 +7,12 @@ def join(parent_path, child_name):
     return f"{parent_path}/{child_name}"
 
 def print_tree():
-    root_id = api.lookup_node_id("/")
     print("/")
-    print_node_info(root_id, indent=1)
+    print_node_info("/", indent=1)
 
-def print_node_info(parent_id, indent):
+def print_node_info(parent_path, indent):
     ws = " "*4*indent
-    for (child_name, child_id, child_type) in api.get_children(parent_id):
+    for (child_name, child_id, child_type) in api.get_children(parent_path):
         match child_type:
             case SceneNodeType.ROOT:
                 child_type = "root"
@@ -51,11 +50,16 @@ def print_node_info(parent_id, indent):
         desc += f"[{child_type}]"
         print(desc)
 
-        print_node_info(child_id, indent+1)
+        if parent_path == "/":
+            child_path = "/" + child_name
+        else:
+            child_path = parent_path + "/" + child_name
+
+        print_node_info(child_path, indent+1)
 
-    for prop in api.get_properties(parent_id):
+    for prop in api.get_properties(parent_path):
         if prop.type != PropertyType.BUFFER:
-            prop_val = api.get_property_value(parent_id, prop.name)
+            prop_val = api.get_property_value(parent_path, prop.name)
 
             if prop.type == PropertyType.STR:
                 prop_val = [f"\"{pv}\"" for pv in prop_val]
@@ -71,17 +75,17 @@ def print_node_info(parent_id, indent):
 
         print(f"{ws}{prop.name}: {prop_type}{prop_val}")
 
-    for sig in api.get_signals(parent_id):
-        print(f"{ws}~{sig}")
-        for slot_id, slot in api.get_slots(parent_id, sig):
-            print(f"{ws}- '{slot}' ({slot_id})")
+    #for sig in api.get_signals(parent_id):
+    #    print(f"{ws}~{sig}")
+    #    for slot_id, slot in api.get_slots(parent_id, sig):
+    #        print(f"{ws}- '{slot}' ({slot_id})")
 
-    for method_name in api.get_methods(parent_id):
-        args, results = api.get_method(parent_id, method_name)
+    #for method_name in api.get_methods(parent_id):
+    #    args, results = api.get_method(parent_id, method_name)
 
-        args = [f"{name}: " + PropertyType.to_str(typ) for (name, _, typ) in args]
-        results = [f"{name}: " + PropertyType.to_str(typ) for (name, _, typ) in results]
+    #    args = [f"{name}: " + PropertyType.to_str(typ) for (name, _, typ) in args]
+    #    results = [f"{name}: " + PropertyType.to_str(typ) for (name, _, typ) in results]
 
-        method_str = f"{method_name}(" + ", ".join(args) + ") -> (" + ", ".join(results) + ")"
-        print(f"{ws}{method_str}")
+    #    method_str = f"{method_name}(" + ", ".join(args) + ") -> (" + ", ".join(results) + ")"
+    #    print(f"{ws}{method_str}")
 

bin/darkwallet/pydrk/api.py

@@ -338,9 +338,9 @@ class Api:
         type = serial.read_u8(cur)
         return (name, type)
 
-    def get_children(self, node_id):
+    def get_children(self, node_path):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         cur = self._make_request(Command.GET_CHILDREN, req)
         children_len = serial.decode_varint(cur)
         children = []
@@ -364,9 +364,9 @@ class Api:
             parents.append((parent_name, parent_id, parent_type))
         return parents
 
-    def get_properties(self, node_id):
+    def get_properties(self, node_path):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         cur = self._make_request(Command.GET_PROPERTIES, req)
         props_len = serial.decode_varint(cur)
         props = []
@@ -427,9 +427,9 @@ class Api:
             case _:
                 raise Exception("unknown property type returned")
 
-    def get_property_value(self, node_id, prop_name):
+    def get_property_value(self, node_path, prop_name):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         cur = self._make_request(Command.GET_PROPERTY_VALUE, req)
         prop_type = serial.read_u8(cur)
@@ -549,71 +549,71 @@ class Api:
         serial.write_u32(req, parent_id)
         self._make_request(Command.UNLINK_NODE, req)
 
-    def set_property_null(self, node_id, prop_name, i):
+    def set_property_null(self, node_path, prop_name, i):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.NULL)
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_bool(self, node_id, prop_name, i, val):
+    def set_property_bool(self, node_path, prop_name, i, val):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.BOOL)
         serial.write_u8(req, int(val))
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_u32(self, node_id, prop_name, i, val):
+    def set_property_u32(self, node_path, prop_name, i, val):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.UINT32)
         serial.write_u32(req, val)
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_f32(self, node_id, prop_name, i, val):
+    def set_property_f32(self, node_path, prop_name, i, val):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.FLOAT32)
         serial.write_f32(req, val)
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_str(self, node_id, prop_name, i, val):
+    def set_property_str(self, node_path, prop_name, i, val):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.STR)
         serial.encode_str(req, val)
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_enum(self, node_id, prop_name, i, val):
+    def set_property_enum(self, node_path, prop_name, i, val):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.ENUM)
         serial.encode_str(req, val)
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_buf(self, node_id, prop_name, i, buf):
+    def set_property_buf(self, node_path, prop_name, i, buf):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.BUFFER)
         serial.encode_buf(req, buf)
         self._make_request(Command.SET_PROPERTY_VALUE, req)
 
-    def set_property_expr(self, node_id, prop_name, i, code):
+    def set_property_expr(self, node_path, prop_name, i, code):
         req = bytearray()
-        serial.write_u32(req, node_id)
+        serial.encode_str(req, node_path)
         serial.encode_str(req, prop_name)
         serial.write_u32(req, i)
         serial.write_u8(req, PropertyType.SEXPR)

bin/darkwallet/src/app/schema.rs

@@ -29,16 +29,7 @@ use crate::{
     scene::{SceneNodePtr, Slot},
     text::TextShaperPtr,
     ui::{
-        Button,
-        ChatView,
-        EditBox,
-        Image,
-        Layer,
-        ShapeVertex,
-        Text,
-        VectorArt,
-        VectorShape,
-        Window,
+        Button, ChatView, EditBox, Image, Layer, ShapeVertex, Text, VectorArt, VectorShape, Window,
     },
     ExecutorPtr,
 };
@@ -424,14 +415,17 @@ pub(super) async fn make_test(app: &App, window: SceneNodePtr) {
         populate_tree(&chat_tree);
     }
     debug!(target: "app", "db has {} lines", chat_tree.len());
-    let node =
-        node.setup(|me| ChatView::new(
+    let node = node
+        .setup(|me| {
+            ChatView::new(
                 me,
-        chat_tree,
-        app.render_api.clone(),
-        app.text_shaper.clone(),
-        app.ex.clone(),
-                )).await;
+                chat_tree,
+                app.render_api.clone(),
+                app.text_shaper.clone(),
+                app.ex.clone(),
+            )
+        })
+        .await;
     layer_node.link(node);
 }
 
@@ -603,14 +597,17 @@ pub(super) async fn make(app: &App, window: SceneNodePtr) {
         populate_tree(&chat_tree);
     }
     debug!(target: "app", "db has {} lines", chat_tree.len());
-    let node =
-        node.setup(|me| ChatView::new(
+    let node = node
+        .setup(|me| {
+            ChatView::new(
                 me,
-        chat_tree,
-        app.render_api.clone(),
-        app.text_shaper.clone(),
-        app.ex.clone(),
-                )).await;
+                chat_tree,
+                app.render_api.clone(),
+                app.text_shaper.clone(),
+                app.ex.clone(),
+            )
+        })
+        .await;
     layer_node.link(node);
 
     // Create the editbox bg

bin/darkwallet/src/main.rs

@@ -51,21 +51,19 @@ mod error;
 mod expr;
 mod gfx;
 mod mesh;
-//mod net;
+mod net;
 //mod plugin;
 mod prop;
 mod pubsub;
 //mod py;
 mod ringbuf;
-//mod scene;
 mod scene;
 use scene::SceneNode as SceneNode3;
 mod text;
 mod ui;
 mod util;
 
-//use crate::{darkirc::DarkIrcBackend, net::ZeroMQAdapter, scene::SceneGraph, text::TextShaper};
-use crate::text::TextShaper;
+use crate::{net::ZeroMQAdapter, text::TextShaper};
 
 pub type ExecutorPtr = Arc<smol::Executor<'static>>;
 
@@ -106,18 +104,18 @@ fn main() {
     }
 
     let ex = Arc::new(smol::Executor::new());
-    let sg3 = SceneNode3::root();
+    let sg_root = SceneNode3::root();
 
     let async_runtime = app::AsyncRuntime::new(ex.clone());
     async_runtime.start();
 
-    //let sg2 = sg.clone();
-    //let ex2 = ex.clone();
-    //let zmq_task = ex.spawn(async {
-    //    let zmq_rpc = ZeroMQAdapter::new(sg2, ex2).await;
-    //    zmq_rpc.run().await;
-    //});
-    //async_runtime.push_task(zmq_task);
+    let sg_root2 = sg_root.clone();
+    let ex2 = ex.clone();
+    let zmq_task = ex.spawn(async {
+        let zmq_rpc = ZeroMQAdapter::new(sg_root2, ex2).await;
+        zmq_rpc.run().await;
+    });
+    async_runtime.push_task(zmq_task);
 
     let (method_req, method_rep) = mpsc::channel();
     // The UI actually needs to be running for this to reply back.
@@ -129,7 +127,7 @@ fn main() {
 
     //let darkirc_backend = DarkIrcBackend::new();
     let app = app::App::new(
-        sg3.clone(),
+        sg_root.clone(),
         render_api.clone(),
         event_pub.clone(),
         text_shaper,

bin/darkwallet/src/net.rs

@@ -28,7 +28,7 @@ use crate::{
     error::{Error, Result},
     expr::SExprCode,
     prop::{Property, PropertySubType, PropertyType, PropertyValue, Role},
-    scene::{SceneGraphPtr2, SceneNodeId, SceneNodeType, Slot, SlotId},
+    scene::{SceneNodeId, SceneNodePtr, ScenePath},
     ExecutorPtr,
 };
 
@@ -77,7 +77,7 @@ pub struct ZeroMQAdapter {
     slot_sender: mpsc::SyncSender<(Vec<u8>, Vec<u8>)>,
     slot_recvr: Option<mpsc::Receiver<(Vec<u8>, Vec<u8>)>>,
     */
-    scene_graph: SceneGraphPtr2,
+    sg_root: SceneNodePtr,
     ex: ExecutorPtr,
 
     zmq_rep: Mutex<zeromq::RepSocket>,
@@ -85,19 +85,14 @@ pub struct ZeroMQAdapter {
 }
 
 impl ZeroMQAdapter {
-    pub async fn new(scene_graph: SceneGraphPtr2, ex: ExecutorPtr) -> Arc<Self> {
+    pub async fn new(sg_root: SceneNodePtr, ex: ExecutorPtr) -> Arc<Self> {
         let mut zmq_rep = zeromq::RepSocket::new();
         zmq_rep.bind("tcp://0.0.0.0:9484").await.unwrap();
 
         let mut zmq_pub = zeromq::PubSocket::new();
         zmq_pub.bind("tcp://0.0.0.0:9485").await.unwrap();
 
-        Arc::new(Self {
-            scene_graph,
-            ex,
-            zmq_rep: Mutex::new(zmq_rep),
-            zmq_pub: Mutex::new(zmq_pub),
-        })
+        Arc::new(Self { sg_root, ex, zmq_rep: Mutex::new(zmq_rep), zmq_pub: Mutex::new(zmq_pub) })
     }
 
     pub async fn run(self: Arc<Self>) {
@@ -135,7 +130,6 @@ impl ZeroMQAdapter {
     }
 
     async fn process_request(self: Arc<Self>, cmd: Command, payload: Vec<u8>) -> Result<Vec<u8>> {
-        let mut scene_graph = self.scene_graph.lock().await;
         let mut cur = Cursor::new(&payload);
         let mut reply = vec![];
         match cmd {
@@ -145,26 +139,30 @@ impl ZeroMQAdapter {
                 "hello".encode(&mut reply).unwrap();
             }
             Command::GetInfo => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({})", cmd, node_id);
 
                 let node = scene_graph.get_node(node_id).ok_or(Error::NodeNotFound)?;
                 node.name.encode(&mut reply).unwrap();
                 node.typ.encode(&mut reply).unwrap();
+                */
             }
             Command::GetChildren => {
-                let node_id = SceneNodeId::decode(&mut cur).unwrap();
-                debug!(target: "req", "{:?}({})", cmd, node_id);
+                let node_path: ScenePath = String::decode(&mut cur).unwrap().parse()?;
+                debug!(target: "req", "{cmd:?}({node_path})");
+                let node =
+                    self.sg_root.clone().lookup_node(node_path).ok_or(Error::NodeNotFound)?;
 
-                let node = scene_graph.get_node(node_id).ok_or(Error::NodeNotFound)?;
                 let children: Vec<_> = node
-                    .children
+                    .get_children()
                     .iter()
-                    .map(|node_inf| (node_inf.name.clone(), node_inf.id, node_inf.typ))
+                    .map(|node| (node.name.clone(), node.id, node.typ))
                     .collect();
                 children.encode(&mut reply).unwrap();
             }
             Command::GetParents => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({})", cmd, node_id);
 
@@ -175,12 +173,14 @@ impl ZeroMQAdapter {
                     .map(|node_inf| (node_inf.name.clone(), node_inf.id, node_inf.typ))
                     .collect();
                 parents.encode(&mut reply).unwrap();
+                */
             }
             Command::GetProperties => {
-                let node_id = SceneNodeId::decode(&mut cur).unwrap();
-                debug!(target: "req", "{:?}({})", cmd, node_id);
+                let node_path: ScenePath = String::decode(&mut cur).unwrap().parse()?;
+                debug!(target: "req", "{cmd:?}({node_path})");
+                let node =
+                    self.sg_root.clone().lookup_node(node_path).ok_or(Error::NodeNotFound)?;
 
-                let node = scene_graph.get_node(node_id).ok_or(Error::NodeNotFound)?;
                 VarInt(node.props.len() as u64).encode(&mut reply).unwrap();
                 for prop in &node.props {
                     prop.name.encode(&mut reply).unwrap();
@@ -198,11 +198,12 @@ impl ZeroMQAdapter {
                 }
             }
             Command::GetPropertyValue => {
-                let node_id = SceneNodeId::decode(&mut cur).unwrap();
+                let node_path: ScenePath = String::decode(&mut cur).unwrap().parse()?;
                 let prop_name = String::decode(&mut cur).unwrap();
-                debug!(target: "req", "{:?}({}, {})", cmd, node_id, prop_name);
+                debug!(target: "req", "{cmd:?}({node_path}, {prop_name})");
+                let node =
+                    self.sg_root.clone().lookup_node(node_path).ok_or(Error::NodeNotFound)?;
 
-                let node = scene_graph.get_node(node_id).ok_or(Error::NodeNotFound)?;
                 let prop = node.get_property(&prop_name).ok_or(Error::PropertyNotFound)?;
                 prop.typ.encode(&mut reply).unwrap();
                 VarInt(prop.get_len() as u64).encode(&mut reply).unwrap();
@@ -222,36 +223,97 @@ impl ZeroMQAdapter {
                     }
                 }
             }
+            Command::SetPropertyValue => {
+                let node_path: ScenePath = String::decode(&mut cur).unwrap().parse()?;
+                let prop_name = String::decode(&mut cur).unwrap();
+                let prop_i = u32::decode(&mut cur).unwrap() as usize;
+                let prop_type = PropertyType::decode(&mut cur).unwrap();
+                debug!(target: "req", "{cmd:?}({node_path}, {prop_name}, {prop_i}, {prop_type:?})");
+
+                let node =
+                    self.sg_root.clone().lookup_node(node_path).ok_or(Error::NodeNotFound)?;
+                let prop = node.get_property(&prop_name).ok_or(Error::PropertyNotFound)?;
+
+                match prop_type {
+                    PropertyType::Null => {
+                        prop.set_null(Role::User, prop_i)?;
+                    }
+                    PropertyType::Bool => {
+                        let val = bool::decode(&mut cur).unwrap();
+                        prop.set_bool(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::Uint32 => {
+                        let val = u32::decode(&mut cur).unwrap();
+                        prop.set_u32(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::Float32 => {
+                        let val = f32::decode(&mut cur).unwrap();
+                        prop.set_f32(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::Str => {
+                        let val = String::decode(&mut cur).unwrap();
+                        prop.set_str(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::Enum => {
+                        let val = String::decode(&mut cur).unwrap();
+                        prop.set_enum(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::Buffer => {
+                        let val = Vec::<u8>::decode(&mut cur).unwrap();
+                        prop.set_buf(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::SceneNodeId => {
+                        let val = SceneNodeId::decode(&mut cur).unwrap();
+                        prop.set_node_id(Role::User, prop_i, val)?;
+                    }
+                    PropertyType::SExpr => {
+                        let val = SExprCode::decode(&mut cur).unwrap();
+                        debug!(target: "req", "  received code {:?}", val);
+                        prop.set_expr(Role::User, prop_i, val)?;
+                    }
+                }
+            }
             Command::AddNode => {
+                /*
                 let node_name = String::decode(&mut cur).unwrap();
                 let node_type = SceneNodeType::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({}, {:?})", cmd, node_name, node_type);
 
                 let node_id = scene_graph.add_node(&node_name, node_type).id;
                 node_id.encode(&mut reply).unwrap();
+                */
             }
             Command::RemoveNode => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({})", cmd, node_id);
                 scene_graph.remove_node(node_id)?;
+                */
             }
             Command::RenameNode => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let node_name = String::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({}, {})", cmd, node_id, node_name);
                 scene_graph.rename_node(node_id, node_name)?;
+                */
             }
             Command::ScanDangling => {
+                /*
                 let dangling = scene_graph.scan_dangling();
                 dangling.encode(&mut reply).unwrap();
+                */
             }
             Command::LookupNodeId => {
+                /*
                 let node_path: String = deserialize(&payload).unwrap();
                 debug!(target: "req", "{:?}({})", cmd, node_path);
                 let node_id = scene_graph.lookup_node_id(&node_path).ok_or(Error::NodeNotFound)?;
                 node_id.encode(&mut reply).unwrap();
+                */
             }
             Command::AddProperty => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let prop_name = String::decode(&mut cur).unwrap();
                 let prop_type = PropertyType::decode(&mut cur).unwrap();
@@ -357,69 +419,26 @@ impl ZeroMQAdapter {
                     prop.set_enum_items(prop_enum_items)?;
                 }
                 node.add_property(prop)?;
+                */
             }
             Command::LinkNode => {
+                /*
                 let child_id = SceneNodeId::decode(&mut cur).unwrap();
                 let parent_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({}, {})", cmd, child_id, parent_id);
                 scene_graph.link(child_id, parent_id)?;
+                */
             }
             Command::UnlinkNode => {
+                /*
                 let child_id = SceneNodeId::decode(&mut cur).unwrap();
                 let parent_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({}, {})", cmd, child_id, parent_id);
                 scene_graph.unlink(child_id, parent_id)?;
-            }
-            Command::SetPropertyValue => {
-                let node_id = SceneNodeId::decode(&mut cur).unwrap();
-                let prop_name = String::decode(&mut cur).unwrap();
-                let prop_i = u32::decode(&mut cur).unwrap() as usize;
-                let prop_type = PropertyType::decode(&mut cur).unwrap();
-                debug!(target: "req", "{:?}({}, {}, {}, {:?})", cmd, node_id, prop_name, prop_i, prop_type);
-
-                let node = scene_graph.get_node_mut(node_id).ok_or(Error::NodeNotFound)?;
-                let prop = node.get_property(&prop_name).ok_or(Error::PropertyNotFound)?;
-
-                match prop_type {
-                    PropertyType::Null => {
-                        prop.set_null(Role::User, prop_i)?;
-                    }
-                    PropertyType::Bool => {
-                        let val = bool::decode(&mut cur).unwrap();
-                        prop.set_bool(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::Uint32 => {
-                        let val = u32::decode(&mut cur).unwrap();
-                        prop.set_u32(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::Float32 => {
-                        let val = f32::decode(&mut cur).unwrap();
-                        prop.set_f32(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::Str => {
-                        let val = String::decode(&mut cur).unwrap();
-                        prop.set_str(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::Enum => {
-                        let val = String::decode(&mut cur).unwrap();
-                        prop.set_enum(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::Buffer => {
-                        let val = Vec::<u8>::decode(&mut cur).unwrap();
-                        prop.set_buf(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::SceneNodeId => {
-                        let val = SceneNodeId::decode(&mut cur).unwrap();
-                        prop.set_node_id(Role::User, prop_i, val)?;
-                    }
-                    PropertyType::SExpr => {
-                        let val = SExprCode::decode(&mut cur).unwrap();
-                        debug!(target: "req", "  received code {:?}", val);
-                        prop.set_expr(Role::User, prop_i, val)?;
-                    }
-                }
+                */
             }
             Command::GetSignals => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({})", cmd, node_id);
 
@@ -430,8 +449,10 @@ impl ZeroMQAdapter {
                     sigs.push(sig.name.clone());
                 }
                 sigs.encode(&mut reply).unwrap();
+                */
             }
             Command::RegisterSlot => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let sig_name = String::decode(&mut cur).unwrap();
                 let slot_name = String::decode(&mut cur).unwrap();
@@ -463,8 +484,10 @@ impl ZeroMQAdapter {
 
                 let slot_id = node.register(&sig_name, slot)?;
                 slot_id.encode(&mut reply).unwrap();
+                */
             }
             Command::UnregisterSlot => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let sig_name = String::decode(&mut cur).unwrap();
                 let slot_id = SlotId::decode(&mut cur).unwrap();
@@ -472,8 +495,10 @@ impl ZeroMQAdapter {
 
                 let node = scene_graph.get_node_mut(node_id).ok_or(Error::NodeNotFound)?;
                 node.unregister(&sig_name, slot_id)?;
+                */
             }
             Command::LookupSlotId => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let sig_name = String::decode(&mut cur).unwrap();
                 let slot_name = String::decode(&mut cur).unwrap();
@@ -483,8 +508,10 @@ impl ZeroMQAdapter {
                 let signal = node.get_signal(&sig_name).ok_or(Error::SignalNotFound)?;
                 let slot_id = signal.lookup_slot_id(&slot_name).ok_or(Error::SlotNotFound)?;
                 slot_id.encode(&mut reply).unwrap();
+                */
             }
             Command::GetSlots => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let sig_name = String::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({}, {})", cmd, node_id, sig_name);
@@ -497,8 +524,10 @@ impl ZeroMQAdapter {
                     slots.push((slot.name.clone(), slot_id));
                 }
                 slots.encode(&mut reply).unwrap();
+                */
             }
             Command::GetMethods => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({})", cmd, node_id);
 
@@ -506,8 +535,10 @@ impl ZeroMQAdapter {
                 let method_names: Vec<_> = node.methods.iter().map(|m| m.name.clone()).collect();
 
                 method_names.encode(&mut reply).unwrap();
+                */
             }
             Command::GetMethod => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let method_name = String::decode(&mut cur).unwrap();
                 debug!(target: "req", "{:?}({}, {})", cmd, node_id, method_name);
@@ -517,8 +548,10 @@ impl ZeroMQAdapter {
 
                 method.args.encode(&mut reply).unwrap();
                 method.result.encode(&mut reply).unwrap();
+                */
             }
             Command::CallMethod => {
+                /*
                 let node_id = SceneNodeId::decode(&mut cur).unwrap();
                 let method_name = String::decode(&mut cur).unwrap();
                 let arg_data = Vec::<u8>::decode(&mut cur).unwrap();
@@ -548,6 +581,7 @@ impl ZeroMQAdapter {
                         0u8.encode(&mut reply).unwrap();
                     }
                 }
+                */
             }
         }