wallet: updated chatview to new backends

bin/darkwallet/src/app/mod.rs

@@ -34,8 +34,7 @@ use crate::{
     prop::{Property, PropertyBool, PropertyStr, PropertySubType, PropertyType, Role},
     scene::{Pimpl, SceneNode as SceneNode3, SceneNodePtr, SceneNodeType as SceneNodeType3},
     text::TextShaperPtr,
-    //ui::{chatview, Button, ChatView, EditBox, Image, Layer, Stoppable, Text, VectorArt, Window},
-    ui::Window,
+    ui::{chatview, Window},
     ExecutorPtr,
 };
 
@@ -222,7 +221,7 @@ impl App {
             })
             .await;
         self.sg_root.link(window.clone());
-        schema::make_test(&self, window).await;
+        schema::make(&self, window).await;
 
         debug!(target: "app", "Schema loaded");
 
@@ -288,11 +287,11 @@ fn populate_tree(tree: &sled::Tree) {
         let mut key = [0u8; 8 + 32];
         key[..8].clone_from_slice(&timest);
 
-        //let msg = chatview::ChatMsg { nick, text };
-        //let mut val = vec![];
-        //msg.encode(&mut val).unwrap();
+        let msg = chatview::ChatMsg { nick, text };
+        let mut val = vec![];
+        msg.encode(&mut val).unwrap();
 
-        //tree.insert(&key, val).unwrap();
+        tree.insert(&key, val).unwrap();
     }
     // O(n)
     debug!(target: "app", "populated db with {} lines", tree.len());

bin/darkwallet/src/app/node.rs

@@ -192,7 +192,7 @@ pub fn create_editbox(name: &str) -> SceneNode {
     node
 }
 
-pub fn create_chatview(name: &str) -> (SceneNode, async_channel::Receiver<Vec<u8>>) {
+pub fn create_chatview(name: &str) -> SceneNode {
     debug!(target: "app", "create_chatview({name})");
     let mut node = SceneNode::new(name, SceneNodeType::ChatView);
 
@@ -258,14 +258,7 @@ pub fn create_chatview(name: &str) -> (SceneNode, async_channel::Receiver<Vec<u8
     prop.set_defaults_f32(vec![1000.]).unwrap();
     node.add_property(prop).unwrap();
 
-    let (sender, recvr) = async_channel::unbounded::<Vec<u8>>();
-    let method = move |data: Vec<u8>, response_fn: MethodResponseFn| {
-        if sender.try_send(data).is_err() {
-            response_fn(Err(Error::ChannelClosed));
-        } else {
-            response_fn(Ok(vec![]));
-        }
-    };
+    /*
     node.add_method(
         "insert_line",
         vec![
@@ -278,6 +271,7 @@ pub fn create_chatview(name: &str) -> (SceneNode, async_channel::Receiver<Vec<u8
         Box::new(method),
     )
     .unwrap();
+    */
 
-    (node, recvr)
+    node
 }

bin/darkwallet/src/app/schema.rs

@@ -30,8 +30,7 @@ use crate::{
     text::TextShaperPtr,
     ui::{
         Button,
-        //chatview, vector_art::shape, Button, ChatView, EditBox, Image, Layer, ShapeVertex,
-        //Stoppable, Text, VectorArt, VectorShape, Window,
+        ChatView,
         EditBox,
         Image,
         Layer,
@@ -355,10 +354,8 @@ pub(super) async fn make_test(app: &App, window: SceneNodePtr) {
         .await;
     layer_node.link(node);
 
-    /*
     // ChatView
-    let (node_id, recvr) = create_chatview(&mut sg, "chatty");
-    let node = sg.get_node(node_id).unwrap();
+    let node = create_chatview("chatty");
     let prop = node.get_property("rect").unwrap();
     prop.set_f32(Role::App, 0, 0.).unwrap();
     let code = cc.compile("h/2").unwrap();
@@ -421,38 +418,21 @@ pub(super) async fn make_test(app: &App, window: SceneNodePtr) {
         prop.set_f32(Role::App, 3, 1.).unwrap();
     }
 
-    drop(sg);
     let db = sled::open(CHATDB_PATH).expect("cannot open sleddb");
     let chat_tree = db.open_tree(b"chat").unwrap();
     if chat_tree.is_empty() {
         populate_tree(&chat_tree);
     }
     debug!(target: "app", "db has {} lines", chat_tree.len());
-    let pimpl = ChatView::new(
-        app.ex.clone(),
-        app.sg.clone(),
-        node_id,
+    let node =
+        node.setup(|me| ChatView::new(
+                me,
+        chat_tree,
         app.render_api.clone(),
         app.text_shaper.clone(),
-        chat_tree,
-        recvr,
-    )
-    .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();
-
-    // On android lets scale the UI up
-    // TODO: add support for fractional scaling
-    // This also affects mouse/touch input since coords need to be accurately translated
-    // Also we need to think about nesting of layers.
-    //let window_node = sg.get_node_mut(window_id).unwrap();
-    //win_node.set_property_f32(Role::App, "scale", 1.6).unwrap();
-
-    // *app.tasks.lock().unwrap() = tasks;
-    */
+        app.ex.clone(),
+                )).await;
+    layer_node.link(node);
 }
 
 pub(super) async fn make(app: &App, window: SceneNodePtr) {
@@ -547,10 +527,8 @@ pub(super) async fn make(app: &App, window: SceneNodePtr) {
         .await;
     layer_node.link(node);
 
-    /*
     // ChatView
-    let (node_id, recvr) = create_chatview(&mut sg, "chatty");
-    let node = sg.get_node(node_id).unwrap();
+    let node = create_chatview("chatty");
     let prop = node.get_property("rect").unwrap();
     prop.set_f32(Role::App, 0, 0.).unwrap();
     prop.set_f32(Role::App, 1, EDITCHAT_HEIGHT).unwrap();
@@ -619,29 +597,21 @@ pub(super) async fn make(app: &App, window: SceneNodePtr) {
         prop.set_f32(Role::App, 3, 1.).unwrap();
     }
 
-    drop(sg);
     let db = sled::open(CHATDB_PATH).expect("cannot open sleddb");
     let chat_tree = db.open_tree(b"chat").unwrap();
     if chat_tree.is_empty() {
         populate_tree(&chat_tree);
     }
     debug!(target: "app", "db has {} lines", chat_tree.len());
-    let pimpl = ChatView::new(
-        app.ex.clone(),
-        app.sg.clone(),
-        node_id,
+    let node =
+        node.setup(|me| ChatView::new(
+                me,
+        chat_tree,
         app.render_api.clone(),
         app.text_shaper.clone(),
-        chat_tree,
-        recvr,
-    )
-    .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();
-    */
+        app.ex.clone(),
+                )).await;
+    layer_node.link(node);
 
     // Create the editbox bg
     let node = create_vector_art("editbox_bg");
@@ -705,10 +675,8 @@ pub(super) async fn make(app: &App, window: SceneNodePtr) {
         .await;
     layer_node.link(node);
 
-    /*
     // Text edit
-    let node_id = create_editbox(&mut sg, "editz");
-    let node = sg.get_node(node_id).unwrap();
+    let node = create_editbox("editz");
     node.set_property_bool(Role::App, "is_active", true).unwrap();
 
     let prop = node.get_property("rect").unwrap();
@@ -757,8 +725,8 @@ pub(super) async fn make(app: &App, window: SceneNodePtr) {
     node.set_property_u32(Role::App, "z_index", 2).unwrap();
     //node.set_property_bool(Role::App, "debug", true).unwrap();
 
-    let editbox_text = PropertyStr::wrap(node, Role::App, "text", 0).unwrap();
-    let editbox_focus = PropertyBool::wrap(node, Role::App, "is_focused", 0).unwrap();
+    //let editbox_text = PropertyStr::wrap(node, Role::App, "text", 0).unwrap();
+    //let editbox_focus = PropertyBool::wrap(node, Role::App, "is_focused", 0).unwrap();
     //let darkirc_backend = app.darkirc_backend.clone();
     //let task = app.ex.spawn(async move {
     //    while let Ok(_) = btn_click_recvr.recv().await {
@@ -777,19 +745,10 @@ pub(super) async fn make(app: &App, window: SceneNodePtr) {
     //});
     //tasks.push(task);
 
-    drop(sg);
-    let pimpl = EditBox::new(
-        app.ex.clone(),
-        app.sg.clone(),
-        node_id,
-        app.render_api.clone(),
-        app.text_shaper.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| {
+            EditBox::new(me, app.render_api.clone(), app.text_shaper.clone(), app.ex.clone())
+        })
+        .await;
+    layer_node.link(node);
 }

bin/darkwallet/src/gfx/mod.rs

@@ -245,7 +245,7 @@ impl<'a> RenderContext<'a> {
 
         let view_x = view.x.round() as i32;
         let view_y = screen_height - (view.y + view.h);
-        let view_y = view.y.round() as i32;
+        let view_y = view_y.round() as i32;
         let view_w = view.w.round() as i32;
         let view_h = view.h.round() as i32;
 
@@ -288,7 +288,7 @@ impl<'a> RenderContext<'a> {
                     }
                 }
                 DrawInstruction::Move(off) => {
-                    self.cursor += *off;
+                    self.cursor = old_cursor + *off;
                     if DEBUG_RENDER {
                         debug!(target: "gfx",
                             "{ws}move({off:?})  cursor={:?}, scale={}, view={:?}",

bin/darkwallet/src/scene.rs

@@ -351,7 +351,7 @@ pub enum Pimpl {
     VectorArt(ui::VectorArtPtr),
     Text(ui::TextPtr),
     EditBox(ui::EditBoxPtr),
-    //ChatView(ui::ChatViewPtr),
+    ChatView(ui::ChatViewPtr),
     Image(ui::ImagePtr),
     Button(ui::ButtonPtr),
 }

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

@@ -49,14 +49,13 @@ use crate::{
         Role,
     },
     pubsub::Subscription,
-    ringbuf::RingBuffer,
-    scene::{Pimpl, SceneGraph, SceneGraphPtr2, SceneNodeId},
+    scene::{Pimpl, SceneNodeWeak},
     text::{self, Glyph, GlyphPositionIter, TextShaperPtr},
     util::{enumerate, is_whitespace},
     ExecutorPtr,
 };
 
-use super::{get_parent_rect, DrawUpdate, OnModify, UIObject};
+use super::{DrawUpdate, OnModify, UIObject};
 
 const EPSILON: f32 = 0.001;
 const BIG_EPSILON: f32 = 0.05;
@@ -134,14 +133,13 @@ impl TouchInfo {
 pub type ChatViewPtr = Arc<ChatView>;
 
 pub struct ChatView {
-    node_id: SceneNodeId,
+    node: SceneNodeWeak,
     #[allow(dead_code)]
     tasks: Vec<smol::Task<()>>,
-    sg: SceneGraphPtr2,
     render_api: RenderApiPtr,
     text_shaper: TextShaperPtr,
-    tree: sled::Tree,
 
+    tree: sled::Tree,
     msgbuf: AsyncMutex<MessageBuffer>,
     dc_key: u64,
 
@@ -167,62 +165,62 @@ pub struct ChatView {
     scroll_resist: PropertyFloat32,
     select_hold_time: PropertyFloat32,
 
-    // Scroll accel
+    /// Scroll accel
     motion_cv: Arc<CondVar>,
     speed: AtomicF32,
 
     mouse_btn_held: AtomicBool,
 
-    // Triggers the background loading task to wake up
+    /// Triggers the background loading task to wake up
     bgload_cv: Arc<CondVar>,
 
-    /// Used for correct converting input event pos from screen to widget space.
-    /// We also use it when we re-eval rect when its changed via property.
+    /// We use it when we re-eval rect when its changed via property.
     parent_rect: SyncMutex<Option<Rectangle>>,
 }
 
 impl ChatView {
     pub async fn new(
-        ex: ExecutorPtr,
-        sg: SceneGraphPtr2,
-        node_id: SceneNodeId,
+        node: SceneNodeWeak,
+        tree: sled::Tree,
         render_api: RenderApiPtr,
-        event_pub: GraphicsEventPublisherPtr,
         text_shaper: TextShaperPtr,
-        tree: sled::Tree,
-        recvr: async_channel::Receiver<Vec<u8>>,
+        ex: ExecutorPtr,
     ) -> Pimpl {
         debug!(target: "ui::chatview", "ChatView::new()");
-        let scene_graph = sg.lock().await;
-        let node = scene_graph.get_node(node_id).unwrap();
-        let node_name = node.name.clone();
-
-        let rect = PropertyRect::wrap(node, Role::Internal, "rect").unwrap();
-        let scroll = PropertyFloat32::wrap(node, Role::Internal, "scroll", 0).unwrap();
-        let font_size = PropertyFloat32::wrap(node, Role::Internal, "font_size", 0).unwrap();
-        let line_height = PropertyFloat32::wrap(node, Role::Internal, "line_height", 0).unwrap();
-        let baseline = PropertyFloat32::wrap(node, Role::Internal, "baseline", 0).unwrap();
-        let timestamp_color = PropertyColor::wrap(node, Role::Internal, "timestamp_color").unwrap();
-        let text_color = PropertyColor::wrap(node, Role::Internal, "text_color").unwrap();
-        let nick_colors = node.get_property("nick_colors").expect("ChatView::nick_colors");
-        let hi_bg_color = PropertyColor::wrap(node, Role::Internal, "hi_bg_color").unwrap();
-        let z_index = PropertyUint32::wrap(node, Role::Internal, "z_index", 0).unwrap();
-        let debug = PropertyBool::wrap(node, Role::Internal, "debug", 0).unwrap();
+
+        let node_ref = &node.upgrade().unwrap();
+        let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
+        let scroll = PropertyFloat32::wrap(node_ref, Role::Internal, "scroll", 0).unwrap();
+        let font_size = PropertyFloat32::wrap(node_ref, Role::Internal, "font_size", 0).unwrap();
+        let line_height =
+            PropertyFloat32::wrap(node_ref, Role::Internal, "line_height", 0).unwrap();
+        let baseline = PropertyFloat32::wrap(node_ref, Role::Internal, "baseline", 0).unwrap();
+        let timestamp_color =
+            PropertyColor::wrap(node_ref, Role::Internal, "timestamp_color").unwrap();
+        let text_color = PropertyColor::wrap(node_ref, Role::Internal, "text_color").unwrap();
+        let nick_colors = node_ref.get_property("nick_colors").expect("ChatView::nick_colors");
+        let hi_bg_color = PropertyColor::wrap(node_ref, Role::Internal, "hi_bg_color").unwrap();
+        let z_index = PropertyUint32::wrap(node_ref, Role::Internal, "z_index", 0).unwrap();
+        let debug = PropertyBool::wrap(node_ref, Role::Internal, "debug", 0).unwrap();
 
         let scroll_start_accel =
-            PropertyFloat32::wrap(node, Role::Internal, "scroll_start_accel", 0).unwrap();
+            PropertyFloat32::wrap(node_ref, Role::Internal, "scroll_start_accel", 0).unwrap();
         let scroll_resist =
-            PropertyFloat32::wrap(node, Role::Internal, "scroll_resist", 0).unwrap();
+            PropertyFloat32::wrap(node_ref, Role::Internal, "scroll_resist", 0).unwrap();
         let select_hold_time =
-            PropertyFloat32::wrap(node, Role::Internal, "select_hold_time", 0).unwrap();
-        drop(scene_graph);
+            PropertyFloat32::wrap(node_ref, Role::Internal, "select_hold_time", 0).unwrap();
+
+        let node_name = node_ref.name.clone();
+        let node_id = node_ref.id;
 
         let self_ = Arc::new_cyclic(|me: &Weak<Self>| {
+            /*
             let me2 = me.clone();
             let insert_line_method_task =
                 ex.spawn(
                     async move { while Self::process_insert_line_method(&me2, &recvr).await {} },
                 );
+            */
 
             let me2 = me.clone();
             let motion_cv = Arc::new(CondVar::new());
@@ -267,17 +265,16 @@ impl ChatView {
             //on_modify.when_change(rect.clone(), redraw);
             //on_modify.when_change(debug.prop(), redraw);
 
-            let mut tasks = vec![insert_line_method_task, motion_task, bgload_task];
+            let mut tasks = vec![/*insert_line_method_task,*/ motion_task, bgload_task];
             tasks.append(&mut on_modify.tasks);
 
             Self {
-                node_id,
+                node,
                 tasks,
-                sg,
                 render_api: render_api.clone(),
                 text_shaper: text_shaper.clone(),
-                tree,
 
+                tree,
                 msgbuf: AsyncMutex::new(MessageBuffer::new(
                     font_size.clone(),
                     line_height.clone(),
@@ -640,14 +637,10 @@ impl ChatView {
             // Because we use the scissor, our actual rect is now rect instead of parent_rect
             let off_x = 0.;
             // This calc decides whether scroll is in terms of pages or pixels
-            let off_y = (scroll + start_pos - y_pos) / rect.h;
-            let scale_x = 1. / rect.w;
-            let scale_y = 1. / rect.h;
-            let model = glam::Mat4::from_translation(glam::Vec3::new(off_x, off_y, 0.)) *
-                glam::Mat4::from_scale(glam::Vec3::new(scale_x, scale_y, 1.));
-
-            instrs.push(GfxDrawInstruction::ApplyMatrix(model));
+            let off_y = (scroll + start_pos - y_pos);
+            let pos = Point::from([0., off_y]);
 
+            instrs.push(GfxDrawInstruction::Move(pos));
             instrs.push(GfxDrawInstruction::Draw(mesh));
         }
 
@@ -661,7 +654,7 @@ impl ChatView {
 
         let (mut mesh_instrs, freed) = self.get_meshes(msgbuf, &rect).await;
 
-        let mut instrs = vec![GfxDrawInstruction::ApplyViewport(rect)];
+        let mut instrs = vec![GfxDrawInstruction::ApplyView(rect)];
         instrs.append(&mut mesh_instrs);
 
         let draw_calls =
@@ -690,11 +683,11 @@ impl UIObject for ChatView {
         self.z_index.get()
     }
 
-    async fn draw(&self, sg: &SceneGraph, parent_rect: &Rectangle) -> Option<DrawUpdate> {
+    async fn draw(&self, parent_rect: Rectangle) -> Option<DrawUpdate> {
         debug!(target: "ui::chatview", "ChatView::draw()");
 
         *self.parent_rect.lock().unwrap() = Some(parent_rect.clone());
-        self.rect.eval(parent_rect).ok()?;
+        self.rect.eval(&parent_rect).ok()?;
         let rect = self.rect.get();
 
         let mut msgbuf = self.msgbuf.lock().await;
@@ -712,7 +705,7 @@ impl UIObject for ChatView {
         let (mut mesh_instrs, freed) = self.get_meshes(&mut msgbuf, &rect).await;
         drop(msgbuf);
 
-        let mut instrs = vec![GfxDrawInstruction::ApplyViewport(rect)];
+        let mut instrs = vec![GfxDrawInstruction::ApplyView(rect)];
         instrs.append(&mut mesh_instrs);
 
         Some(DrawUpdate {
@@ -726,13 +719,7 @@ impl UIObject for ChatView {
         })
     }
 
-    async fn handle_key_down(
-        &self,
-        sg: &SceneGraph,
-        key: KeyCode,
-        mods: KeyMods,
-        repeat: bool,
-    ) -> bool {
+    async fn handle_key_down(&self, key: KeyCode, mods: KeyMods, repeat: bool) -> bool {
         if repeat {
             return false
         }
@@ -752,12 +739,7 @@ impl UIObject for ChatView {
         true
     }
 
-    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 btn != MouseButton::Left {
             return false
         }
@@ -772,12 +754,7 @@ impl UIObject for ChatView {
         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 btn != MouseButton::Left {
             return false
         }
@@ -786,7 +763,7 @@ impl UIObject for ChatView {
         false
     }
 
-    async fn handle_mouse_move(&self, sg: &SceneGraph, mouse_pos: Point) -> bool {
+    async fn handle_mouse_move(&self, mouse_pos: Point) -> bool {
         //debug!(target: "ui::chatview", "handle_mouse_move({mouse_x}, {mouse_y})");
 
         // We store the mouse pos for use in handle_mouse_wheel()
@@ -805,7 +782,7 @@ impl UIObject for ChatView {
         false
     }
 
-    async fn handle_mouse_wheel(&self, sg: &SceneGraph, wheel_pos: Point) -> bool {
+    async fn handle_mouse_wheel(&self, wheel_pos: Point) -> bool {
         //debug!(target: "ui::chatview", "handle_mouse_wheel({wheel_x}, {wheel_y})");
 
         let rect = self.rect.get();
@@ -821,13 +798,7 @@ impl UIObject for ChatView {
         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 {
         // Ignore multi-touch
         if id != 0 {
             return false

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

@@ -36,7 +36,6 @@ use crate::{
     mesh::{Color, MeshBuilder, COLOR_BLUE, COLOR_GREEN, COLOR_PINK},
     prop::{PropertyBool, PropertyColor, PropertyFloat32, PropertyPtr, PropertyUint32, Role},
     pubsub::Subscription,
-    scene::{Pimpl, SceneGraph, SceneGraphPtr2, SceneNodeId},
     text::{self, glyph_str, Glyph, GlyphPositionIter, TextShaper, TextShaperPtr},
     util::{enumerate_mut, enumerate_ref},
     ExecutorPtr,

bin/darkwallet/src/ui/mod.rs

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