wallet: migrate to handle_key_up/down()

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

@@ -16,12 +16,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use async_trait::async_trait;
 use async_lock::Mutex as AsyncMutex;
 use atomic_float::AtomicF32;
 use chrono::{Local, TimeZone};
 use darkfi::system::{msleep, CondVar};
 use darkfi_serial::{
-    async_trait, deserialize, Decodable, Encodable, SerialDecodable, SerialEncodable,
+    deserialize, Decodable, Encodable, SerialDecodable, SerialEncodable,
 };
 use miniquad::{KeyCode, KeyMods, MouseButton, TouchPhase};
 use rand::{rngs::OsRng, Rng};
@@ -241,11 +242,6 @@ impl ChatView {
             let touch_task =
                 ex.spawn(async move { while Self::process_touch(&me2, &ev_sub).await {} });
 
-            let ev_sub = event_pub.subscribe_key_down();
-            let me2 = me.clone();
-            let key_down_task =
-                ex.spawn(async move { while Self::process_key_down(&me2, &ev_sub).await {} });
-
             let me2 = me.clone();
             let insert_line_method_task =
                 ex.spawn(
@@ -301,7 +297,6 @@ impl ChatView {
                 mouse_btn_down_task,
                 mouse_btn_up_task,
                 touch_task,
-                key_down_task,
                 insert_line_method_task,
                 motion_task,
                 bgload_task,
@@ -447,39 +442,6 @@ impl ChatView {
         true
     }
 
-    async fn process_key_down(
-        me: &Weak<Self>,
-        ev_sub: &Subscription<(KeyCode, KeyMods, bool)>,
-    ) -> bool {
-        let Ok((key, _mods, repeat)) = ev_sub.receive().await else {
-            debug!(target: "ui::editbox", "Event relayer closed");
-            return false
-        };
-
-        if repeat {
-            return true
-        }
-
-        let Some(self_) = me.upgrade() else {
-            // Should not happen
-            panic!("self destroyed before char_task was stopped!");
-        };
-
-        match key {
-            KeyCode::PageUp => {
-                let scroll = self_.scroll.get() + 200.;
-                self_.scrollview(scroll).await;
-            }
-            KeyCode::PageDown => {
-                let scroll = self_.scroll.get() - 200.;
-                self_.scrollview(scroll).await;
-            }
-            _ => {}
-        }
-
-        true
-    }
-
     async fn process_insert_line_method(
         me: &Weak<Self>,
         recvr: &async_channel::Receiver<Vec<u8>>,
@@ -1030,8 +992,29 @@ impl ChatView {
     }
 }
 
+#[async_trait]
 impl UIObject for ChatView {
     fn z_index(&self) -> u32 {
         self.z_index.get()
     }
+
+    async fn handle_key_down(&self, sg: &SceneGraph, key: KeyCode, mods: KeyMods, repeat: bool) -> bool {
+        if repeat {
+            return false
+        }
+
+        match key {
+            KeyCode::PageUp => {
+                let scroll = self.scroll.get() + 200.;
+                self.scrollview(scroll).await;
+            }
+            KeyCode::PageDown => {
+                let scroll = self.scroll.get() - 200.;
+                self.scrollview(scroll).await;
+            }
+            _ => {}
+        }
+
+        true
+    }
 }

bin/darkwallet/src/ui/editbox.rs

@@ -217,34 +217,6 @@ impl EditBox {
         let glyphs = text_shaper.shape(text.get(), font_size.get()).await;
 
         let self_ = Arc::new_cyclic(|me: &Weak<Self>| {
-            // Start a task monitoring for key down events
-            let ev_sub = event_pub.subscribe_key_down();
-            let me2 = me.clone();
-            let key_down_task =
-                ex.spawn(async move { while Self::process_key_down(&me2, &ev_sub).await {} });
-
-            /*
-            let ev_sub = event_pub.subscribe_key_up();
-            let me2 = me.clone();
-            let key_up_task = ex.spawn(async move {
-                loop {
-                    let Ok((key, mods)) = ev_sub.receive().await else {
-                        debug!(target: "ui::editbox", "Event relayer closed");
-                        break
-                    };
-
-                    let Some(self_) = me2.upgrade() else {
-                        // Should not happen
-                        panic!("self destroyed before key_up_task was stopped!");
-                    };
-
-                    let key = PressedKey::Key(key);
-                    let mut repeater = self_.key_repeat.lock().unwrap();
-                    repeater.key_up(&key);
-                }
-            });
-            */
-
             let ev_sub = event_pub.subscribe_mouse_btn_down();
             let me2 = me.clone();
             let mouse_btn_down_task =
@@ -300,7 +272,6 @@ impl EditBox {
 
             // on modify tasks too
             let mut tasks = vec![
-                key_down_task,
                 mouse_btn_down_task,
                 mouse_btn_up_task,
                 mouse_move_task,
@@ -478,44 +449,6 @@ impl EditBox {
         Ok(())
     }
 
-    async fn process_key_down(
-        me: &Weak<Self>,
-        ev_sub: &Subscription<(KeyCode, KeyMods, bool)>,
-    ) -> bool {
-        let Ok((key, mods, repeat)) = ev_sub.receive().await else {
-            debug!(target: "ui::editbox", "Event relayer closed");
-            return false
-        };
-
-        // First filter for only single digit keys
-        // Avoid processing events handled by insert_char()
-        if !ALLOWED_KEYCODES.contains(&key) {
-            return true
-        }
-
-        let Some(self_) = me.upgrade() else {
-            // Should not happen
-            panic!("self destroyed before char_task was stopped!");
-        };
-
-        if !self_.is_focused.get() {
-            return true
-        }
-
-        let actions = {
-            let mut repeater = self_.key_repeat.lock().unwrap();
-            repeater.key_down(PressedKey::Key(key), repeat)
-        };
-        // Suppress noisy message
-        if actions > 0 {
-            debug!(target: "ui::editbox", "Key {:?} has {} actions", key, actions);
-        }
-        for _ in 0..actions {
-            self_.handle_key(&key, &mods).await;
-        }
-        true
-    }
-
     async fn process_mouse_btn_down(
         me: &Weak<Self>,
         ev_sub: &Subscription<(MouseButton, f32, f32)>,
@@ -1282,6 +1215,31 @@ impl UIObject for EditBox {
         }
         true
     }
+
+    async fn handle_key_down(&self, sg: &SceneGraph, key: KeyCode, mods: KeyMods, repeat: bool) -> bool {
+        // First filter for only single digit keys
+        // Avoid processing events handled by insert_char()
+        if !ALLOWED_KEYCODES.contains(&key) {
+            return false
+        }
+
+        if !self.is_focused.get() {
+            return false
+        }
+
+        let actions = {
+            let mut repeater = self.key_repeat.lock().unwrap();
+            repeater.key_down(PressedKey::Key(key), repeat)
+        };
+        // Suppress noisy message
+        if actions > 0 {
+            debug!(target: "ui::editbox", "Key {:?} has {} actions", key, actions);
+        }
+        for _ in 0..actions {
+            self.handle_key(&key, &mods).await;
+        }
+        true
+    }
 }
 
 /// Filter these char events from being handled since we handle them

bin/darkwallet/src/ui/layer.rs

@@ -18,7 +18,7 @@
 
 use async_trait::async_trait;
 use async_recursion::async_recursion;
-use miniquad::KeyMods;
+use miniquad::{KeyMods, KeyCode};
 use rand::{rngs::OsRng, Rng};
 use std::sync::{Arc, Weak};
 
@@ -200,5 +200,16 @@ impl UIObject for RenderLayer {
         }
         false
     }
+
+    async fn handle_key_down(&self, sg: &SceneGraph, key: KeyCode, mods: KeyMods, repeat: bool) -> bool {
+        for child_id in get_child_nodes_ordered(&sg, self.node_id) {
+            let node = sg.get_node(child_id).unwrap();
+            let obj = get_ui_object(node);
+            if obj.handle_key_down(&sg, key, mods, repeat).await {
+                return true
+            }
+        }
+        false
+    }
 }
 

bin/darkwallet/src/ui/mod.rs

@@ -18,7 +18,7 @@
 
 use async_trait::async_trait;
 use std::sync::{Arc, Weak};
-use miniquad::KeyMods;
+use miniquad::{KeyMods, KeyCode};
 
 use crate::{
     error::{Error, Result},
@@ -58,6 +58,8 @@ pub trait UIObject: Sync {
     fn z_index(&self) -> u32;
 
     async fn handle_char(&self, sg: &SceneGraph, key: char, mods: KeyMods, repeat: bool) -> bool { false }
+    async fn handle_key_down(&self, sg: &SceneGraph, key: KeyCode, mods: KeyMods, repeat: bool) -> bool { false }
+    async fn handle_key_up(&self, sg: &SceneGraph, key: KeyCode, mods: KeyMods) -> bool { false }
 }
 
 pub struct DrawUpdate {

bin/darkwallet/src/ui/win.rs

@@ -17,7 +17,7 @@
  */
 
 use std::sync::{Arc, Weak};
-use miniquad::KeyMods;
+use miniquad::{KeyMods, KeyCode};
 
 use crate::{
     gfx::{GfxDrawCall, GraphicsEventPublisherPtr, Rectangle, RenderApiPtr},
@@ -93,7 +93,6 @@ impl Window {
             let char_task =
                 ex.spawn(async move { while Self::process_char(&me2, &ev_sub).await {} });
 
-            /*
             let ev_sub = event_pub.subscribe_key_down();
             let me2 = me.clone();
             let key_down_task =
@@ -104,6 +103,7 @@ impl Window {
             let key_up_task =
                 ex.spawn(async move { while Self::process_key_up(&me2, &ev_sub).await {} });
 
+            /*
             let ev_sub = event_pub.subscribe_mouse_btn_down();
             let me2 = me.clone();
             let mouse_btn_down_task =
@@ -135,8 +135,8 @@ impl Window {
             let mut tasks = vec![
                 resize_task,
                 char_task,
-                //key_down_task,
-                //key_up_task,
+                key_down_task,
+                key_up_task,
                 //mouse_btn_down_task,
                 //mouse_btn_up_task,
                 //mouse_move_task,
@@ -165,6 +165,42 @@ impl Window {
         true
     }
 
+    async fn process_key_down(
+        me: &Weak<Self>,
+        ev_sub: &Subscription<(KeyCode, KeyMods, bool)>,
+    ) -> bool {
+        let Ok((key, mods, repeat)) = ev_sub.receive().await else {
+            debug!(target: "ui::win", "Event relayer closed");
+            return false
+        };
+
+        let Some(self_) = me.upgrade() else {
+            // Should not happen
+            panic!("self destroyed before char_task was stopped!");
+        };
+
+        self_.handle_key_down(key, mods, repeat).await;
+        true
+    }
+
+    async fn process_key_up(
+        me: &Weak<Self>,
+        ev_sub: &Subscription<(KeyCode, KeyMods)>,
+    ) -> bool {
+        let Ok((key, mods)) = ev_sub.receive().await else {
+            debug!(target: "ui::win", "Event relayer closed");
+            return false
+        };
+
+        let Some(self_) = me.upgrade() else {
+            // Should not happen
+            panic!("self destroyed before char_task was stopped!");
+        };
+
+        self_.handle_key_up(key, mods).await;
+        true
+    }
+
     async fn handle_char(&self, key: char, mods: KeyMods, repeat: bool) {
         let sg = self.sg.lock().await;
 
@@ -177,6 +213,30 @@ impl Window {
         }
     }
 
+    async fn handle_key_down(&self, key: KeyCode, mods: KeyMods, repeat: bool) {
+        let sg = self.sg.lock().await;
+
+        for child_id in get_child_nodes_ordered(&sg, self.node_id) {
+            let node = sg.get_node(child_id).unwrap();
+            let obj = get_ui_object(node);
+            if obj.handle_key_down(&sg, key, mods, repeat).await {
+                return
+            }
+        }
+    }
+
+    async fn handle_key_up(&self, key: KeyCode, mods: KeyMods) {
+        let sg = self.sg.lock().await;
+
+        for child_id in get_child_nodes_ordered(&sg, self.node_id) {
+            let node = sg.get_node(child_id).unwrap();
+            let obj = get_ui_object(node);
+            if obj.handle_key_up(&sg, key, mods).await {
+                return
+            }
+        }
+    }
+
     pub async fn draw(&self, sg: &SceneGraph) {
         let screen_width = self.screen_size_prop.get_f32(0).unwrap();
         let screen_height = self.screen_size_prop.get_f32(1).unwrap();