diff --git a/bin/darkwallet/src/app.rs b/bin/darkwallet/src/app.rs index 773a562a8..ce7abbdab 100644 --- a/bin/darkwallet/src/app.rs +++ b/bin/darkwallet/src/app.rs @@ -297,7 +297,7 @@ impl App { node.set_property_f32("font_size", 60.).unwrap(); node.set_property_str("text", "anon1🍆").unwrap(); //node.set_property_str("text", "anon1").unwrap(); - let prop = node.get_property("color").unwrap(); + let prop = node.get_property("text_color").unwrap(); prop.set_f32(0, 0.).unwrap(); prop.set_f32(1, 1.).unwrap(); prop.set_f32(2, 0.).unwrap(); @@ -324,11 +324,15 @@ impl App { node.set_property_bool("is_active", true).unwrap(); let prop = node.get_property("rect").unwrap(); prop.set_f32(0, 150.).unwrap(); - let code = - vec![Op::Sub((Box::new(Op::LoadVar("lh".to_string())), Box::new(Op::ConstFloat32(60.))))]; + let code = vec![Op::Sub(( + Box::new(Op::LoadVar("h".to_string())), + Box::new(Op::ConstFloat32(60.)), + ))]; prop.set_expr(1, code).unwrap(); - let code = - vec![Op::Sub((Box::new(Op::LoadVar("lw".to_string())), Box::new(Op::ConstFloat32(120.))))]; + let code = vec![Op::Sub(( + Box::new(Op::LoadVar("w".to_string())), + Box::new(Op::ConstFloat32(120.)), + ))]; prop.set_expr(2, code).unwrap(); prop.set_f32(3, 60.).unwrap(); node.set_property_f32("baseline", 40.).unwrap(); @@ -356,11 +360,12 @@ impl App { drop(sg); let pimpl = EditBox::new( - //self.ex.clone(), - //self.sg.clone(), - //node_id, - //self.render_api.clone(), - //self.text_shaper.clone(), + self.ex.clone(), + self.sg.clone(), + node_id, + self.render_api.clone(), + self.event_pub.clone(), + self.text_shaper.clone(), ) .await; let mut sg = self.sg.lock().await; @@ -424,7 +429,7 @@ fn create_text(sg: &mut SceneGraph, name: &str) -> SceneNodeId { let prop = Property::new("text", PropertyType::Str, PropertySubType::Null); node.add_property(prop).unwrap(); - let mut prop = Property::new("color", PropertyType::Float32, PropertySubType::Color); + let mut prop = Property::new("text_color", PropertyType::Float32, PropertySubType::Color); prop.set_array_len(4); prop.set_range_f32(0., 1.); node.add_property(prop).unwrap(); diff --git a/bin/darkwallet/src/gfx2.rs b/bin/darkwallet/src/gfx2.rs index c73eb06cc..f79e8334e 100644 --- a/bin/darkwallet/src/gfx2.rs +++ b/bin/darkwallet/src/gfx2.rs @@ -304,6 +304,10 @@ pub struct GraphicsEventPublisher { lock_key_down: SyncMutex>, key_down: PublisherPtr<(KeyCode, KeyMods, bool)>, + lock_key_up: SyncMutex>, + key_up: PublisherPtr<(KeyCode, KeyMods)>, + + lock_resize: SyncMutex>, resize: PublisherPtr<(f32, f32)>, } @@ -312,7 +316,11 @@ impl GraphicsEventPublisher { Arc::new(Self { lock_key_down: SyncMutex::new(None), key_down: Publisher::new(), - resize: Publisher::new() }) + lock_key_up: SyncMutex::new(None), + key_up: Publisher::new(), + lock_resize: SyncMutex::new(None), + resize: Publisher::new(), + }) } fn lock_key_down(&self, sub_id: SubscriptionId) { @@ -322,6 +330,20 @@ impl GraphicsEventPublisher { *self.lock_key_down.lock().unwrap() = None; } + fn lock_key_up(&self, sub_id: SubscriptionId) { + *self.lock_key_up.lock().unwrap() = Some(sub_id); + } + fn unlock_key_up(&self) { + *self.lock_key_up.lock().unwrap() = None; + } + + fn lock_resize(&self, sub_id: SubscriptionId) { + *self.lock_resize.lock().unwrap() = Some(sub_id); + } + fn unlock_resize(&self) { + *self.lock_resize.lock().unwrap() = None; + } + fn notify_key_down(&self, key: KeyCode, mods: KeyMods, repeat: bool) { let ev = (key, mods, repeat); @@ -332,13 +354,33 @@ impl GraphicsEventPublisher { self.key_down.notify(ev); } } + fn notify_key_up(&self, key: KeyCode, mods: KeyMods) { + let ev = (key, mods); + + let locked = self.lock_key_up.lock().unwrap().clone(); + if let Some(locked) = locked { + self.key_up.notify_with_include(ev, &[locked]); + } else { + self.key_up.notify(ev); + } + } fn notify_resize(&self, w: f32, h: f32) { - self.resize.notify((w, h)); + let ev = (w, h); + + let locked = self.lock_resize.lock().unwrap().clone(); + if let Some(locked) = locked { + self.resize.notify_with_include(ev, &[locked]); + } else { + self.resize.notify(ev); + } } pub fn subscribe_key_down(&self) -> Subscription<(KeyCode, KeyMods, bool)> { self.key_down.clone().subscribe() } + pub fn subscribe_key_up(&self) -> Subscription<(KeyCode, KeyMods)> { + self.key_up.clone().subscribe() + } pub fn subscribe_resize(&self) -> Subscription<(f32, f32)> { self.resize.clone().subscribe() } @@ -432,15 +474,15 @@ impl Stage { sendr: async_channel::Sender, ) { let texture = self.ctx.new_texture_from_rgba8(width, height, &data); - debug!(target: "gfx2", "Invoked method: new_texture({}, {}, ...) -> {:?}", - width, height, texture); + //debug!(target: "gfx2", "Invoked method: new_texture({}, {}, ...) -> {:?}", + // width, height, texture); //debug!(target: "gfx2", "Invoked method: new_texture({}, {}, ...) -> {:?}\n{}", // width, height, texture, // ansi_texture(width as usize, height as usize, &data)); sendr.try_send(texture).unwrap(); } fn method_delete_texture(&mut self, texture: TextureId) { - debug!(target: "gfx2", "Invoked method: delete_texture({:?})", texture); + //debug!(target: "gfx2", "Invoked method: delete_texture({:?})", texture); self.ctx.delete_texture(texture); } fn method_new_vertex_buffer( @@ -453,7 +495,7 @@ impl Stage { BufferUsage::Immutable, BufferSource::slice(&verts), ); - debug!(target: "gfx2", "Invoked method: new_vertex_buffer({:?}) -> {:?}", verts, buffer); + //debug!(target: "gfx2", "Invoked method: new_vertex_buffer({:?}) -> {:?}", verts, buffer); sendr.try_send(buffer).unwrap(); } fn method_new_index_buffer( @@ -466,15 +508,15 @@ impl Stage { BufferUsage::Immutable, BufferSource::slice(&indices), ); - debug!(target: "gfx2", "Invoked method: new_index_buffer({:?}) -> {:?}", indices, buffer); + //debug!(target: "gfx2", "Invoked method: new_index_buffer({:?}) -> {:?}", indices, buffer); sendr.try_send(buffer).unwrap(); } fn method_delete_buffer(&mut self, buffer: BufferId) { - debug!(target: "gfx2", "Invoked method: delete_buffer({:?})", buffer); + //debug!(target: "gfx2", "Invoked method: delete_buffer({:?})", buffer); self.ctx.delete_buffer(buffer); } fn method_replace_draw_calls(&mut self, dcs: Vec<(u64, DrawCall)>) { - debug!(target: "gfx2", "Invoked method: replace_draw_calls({:?})", dcs); + //debug!(target: "gfx2", "Invoked method: replace_draw_calls({:?})", dcs); for (key, val) in dcs { self.draw_calls.insert(key, val); } @@ -550,6 +592,9 @@ impl EventHandler for Stage { fn key_down_event(&mut self, keycode: KeyCode, mods: KeyMods, repeat: bool) { self.event_pub.notify_key_down(keycode, mods, repeat); } + fn key_up_event(&mut self, keycode: KeyCode, mods: KeyMods) { + self.event_pub.notify_key_up(keycode, mods); + } fn resize_event(&mut self, width: f32, height: f32) { self.event_pub.notify_resize(width, height); } @@ -557,6 +602,10 @@ impl EventHandler for Stage { fn quit_requested_event(&mut self) { self.async_runtime.stop(); } + + fn char_event(&mut self, chr: char, mods: KeyMods, repeat: bool) { + //debug!("chr: {chr}, mods: {:?} repeat: {repeat}", mods); + } } pub fn run_gui( diff --git a/bin/darkwallet/src/main.rs b/bin/darkwallet/src/main.rs index ab9986081..147d417f4 100644 --- a/bin/darkwallet/src/main.rs +++ b/bin/darkwallet/src/main.rs @@ -114,6 +114,23 @@ fn main() { } }); async_runtime.push_task(ev_relay_task); + let ev_sub = event_pub.subscribe_key_up(); + let ev_relay_task = ex.spawn(async move { + debug!(target: "main", "event relayer started"); + loop { + let Ok((key, mods)) = ev_sub.receive().await else { + debug!(target: "main", "Event relayer closed"); + break + }; + // Ignore keys which get stuck repeating when switching windows + match key { + miniquad::KeyCode::LeftShift | miniquad::KeyCode::LeftSuper => continue, + _ => {} + } + debug!(target: "main", "key_up event: {:?} {:?}", key, mods); + } + }); + async_runtime.push_task(ev_relay_task); //let stage = gfx2::Stage::new(method_rep, event_pub); gfx2::run_gui(async_runtime, method_rep, event_pub); diff --git a/bin/darkwallet/src/text2.rs b/bin/darkwallet/src/text2.rs index 70d773c75..5924f00f9 100644 --- a/bin/darkwallet/src/text2.rs +++ b/bin/darkwallet/src/text2.rs @@ -516,6 +516,7 @@ pub struct Sprite { pub has_color: bool, } +#[derive(Clone)] pub struct Glyph { pub glyph_id: u32, // Substring this glyph corresponds to diff --git a/bin/darkwallet/src/ui/editbox.rs b/bin/darkwallet/src/ui/editbox.rs index 81ae68494..2bf8ce64a 100644 --- a/bin/darkwallet/src/ui/editbox.rs +++ b/bin/darkwallet/src/ui/editbox.rs @@ -1,6 +1,25 @@ -use std::sync::{Arc, Mutex, Weak}; +use miniquad::{BufferId, KeyCode, KeyMods, TextureId}; +use rand::{rngs::OsRng, Rng}; +use std::{ + collections::HashMap, + sync::{Arc, Mutex as SyncMutex, Weak}, + time::Instant, +}; -use crate::scene::Pimpl; +use crate::{ + gfx2::{ + DrawCall, DrawInstruction, DrawMesh, GraphicsEventPublisherPtr, Rectangle, RenderApi, + RenderApiPtr, Vertex, + }, + mesh::{Color, MeshBuilder, MeshInfo, COLOR_BLUE, COLOR_WHITE}, + prop::{ + PropertyBool, PropertyColor, PropertyFloat32, PropertyPtr, PropertyStr, PropertyUint32, + }, + scene::{Pimpl, SceneGraph, SceneGraphPtr2, SceneNodeId}, + text2::{self, Glyph, GlyphPositionIter, RenderedAtlas, SpritePtr, TextShaper, TextShaperPtr}, +}; + +use super::{eval_rect, get_parent_rect, read_rect, DrawUpdate, OnModify, Stoppable}; // First refactor the event system // Each event should have its own unique pipe @@ -9,17 +28,471 @@ use crate::scene::Pimpl; // - more advanced locking of streams when widgets capture input // also add capturing and make use of it with editbox. +const CURSOR_WIDTH: f32 = 4.; + +struct PressedKeysSmoothRepeat { + /// When holding keys, we track from start and last sent time. + /// This is useful for initial delay and smooth scrolling. + pressed_keys: HashMap, + /// Initial delay before allowing keys + start_delay: u32, + /// Minimum time between repeated keys + step_time: u32, +} + +impl PressedKeysSmoothRepeat { + fn new(start_delay: u32, step_time: u32) -> Self { + Self { pressed_keys: HashMap::new(), start_delay, step_time } + } + + fn key_down(&mut self, key: KeyCode, repeat: bool) -> u32 { + if !repeat { + return 1; + } + + // Insert key if not exists + if !self.pressed_keys.contains_key(&key) { + self.pressed_keys.insert(key, RepeatingKeyTimer::new()); + } + + let repeater = self.pressed_keys.get_mut(&key).expect("repeat map"); + repeater.update(self.start_delay, self.step_time) + } + + fn key_up(&mut self, key: &KeyCode) { + self.pressed_keys.remove(key); + } +} + +struct RepeatingKeyTimer { + start: Instant, + actions: u32, +} + +impl RepeatingKeyTimer { + fn new() -> Self { + Self { start: Instant::now(), actions: 0 } + } + + fn update(&mut self, start_delay: u32, step_time: u32) -> u32 { + let elapsed = self.start.elapsed().as_millis(); + if elapsed < start_delay as u128 { + return 0 + } + let total_actions = ((elapsed - start_delay as u128) / step_time as u128) as u32; + let remaining_actions = total_actions - self.actions; + self.actions = total_actions; + remaining_actions + } +} + +#[derive(Clone)] +struct TextRenderInfo { + glyphs: Vec, + mesh: MeshInfo, + texture_id: TextureId, +} + pub type EditBoxPtr = Arc; pub struct EditBox { + node_id: SceneNodeId, + tasks: Vec>, + sg: SceneGraphPtr2, + render_api: RenderApiPtr, + // So we can lock the event stream when we gain focus + event_pub: GraphicsEventPublisherPtr, + text_shaper: TextShaperPtr, + key_repeat: SyncMutex, + + render_info: SyncMutex, + dc_key: u64, + + is_active: PropertyBool, + rect: PropertyPtr, + baseline: PropertyFloat32, + scroll: PropertyFloat32, + cursor_pos: PropertyUint32, + font_size: PropertyFloat32, + text: PropertyStr, + text_color: PropertyColor, + cursor_color: PropertyColor, + hi_bg_color: PropertyColor, + selected: PropertyPtr, + z_index: PropertyUint32, + debug: PropertyBool, } impl EditBox { pub async fn new( + ex: Arc>, + sg: SceneGraphPtr2, + node_id: SceneNodeId, + render_api: RenderApiPtr, + event_pub: GraphicsEventPublisherPtr, + text_shaper: TextShaperPtr, ) -> Pimpl { - let self_ = Arc::new(Self {}); + let scene_graph = sg.lock().await; + let node = scene_graph.get_node(node_id).unwrap(); + let is_active = PropertyBool::wrap(node, "is_active", 0).unwrap(); + let rect = node.get_property("rect").expect("EditBox::rect"); + let baseline = PropertyFloat32::wrap(node, "baseline", 0).unwrap(); + let scroll = PropertyFloat32::wrap(node, "scroll", 0).unwrap(); + let cursor_pos = PropertyUint32::wrap(node, "cursor_pos", 0).unwrap(); + let font_size = PropertyFloat32::wrap(node, "font_size", 0).unwrap(); + let text = PropertyStr::wrap(node, "text", 0).unwrap(); + let text_color = PropertyColor::wrap(node, "text_color").unwrap(); + let cursor_color = PropertyColor::wrap(node, "cursor_color").unwrap(); + let hi_bg_color = PropertyColor::wrap(node, "hi_bg_color").unwrap(); + let selected = node.get_property("selected").unwrap(); + let z_index = PropertyUint32::wrap(node, "z_index", 0).unwrap(); + let debug = PropertyBool::wrap(node, "debug", 0).unwrap(); + drop(scene_graph); + + let render_info = Self::regen_mesh( + &render_api, + &text_shaper, + text.get(), + font_size.get(), + text_color.get(), + baseline.get(), + debug.get(), + ) + .await; + + let self_ = Arc::new_cyclic(|me: &Weak| { + // 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 { + loop { + let Ok((key, mods, repeat)) = 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_down_task was stopped!"); + }; + + let actions = { + let mut repeater = self_.key_repeat.lock().unwrap(); + repeater.key_down(key, repeat) + }; + for _ in 0..actions { + self_.do_key_action(&key, &mods).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 actions = { + let mut repeater = self_.key_repeat.lock().unwrap(); + repeater.key_up(&key) + }; + } + }); + + // on modify tasks too + let tasks = vec![key_down_task, key_up_task]; + + Self { + node_id, + tasks, + sg, + render_api, + event_pub, + text_shaper, + key_repeat: SyncMutex::new(PressedKeysSmoothRepeat::new(400, 50)), + + render_info: SyncMutex::new(render_info), + dc_key: OsRng.gen(), + + is_active, + rect, + baseline, + scroll, + cursor_pos, + font_size, + text, + text_color, + cursor_color, + hi_bg_color, + selected, + z_index, + debug, + } + }); Pimpl::EditBox(self_) } + + /// Called whenever the text or any text property changes. + /// Not related to cursor, text highlighting or bounding (clip) rects. + async fn regen_mesh( + render_api: &RenderApi, + text_shaper: &TextShaper, + text: String, + font_size: f32, + text_color: Color, + baseline: f32, + debug: bool, + ) -> TextRenderInfo { + debug!(target: "ui::editbox", "Rendering text '{}'", text); + let glyphs = text_shaper.shape(text, font_size).await; + let atlas = text2::make_texture_atlas(render_api, font_size, &glyphs).await.unwrap(); + + let mut mesh = MeshBuilder::new(); + let mut glyph_pos_iter = GlyphPositionIter::new(font_size, &glyphs, baseline); + for ((uv_rect, glyph_rect), glyph) in + atlas.uv_rects.into_iter().zip(glyph_pos_iter).zip(glyphs.iter()) + { + //mesh.draw_outline(&glyph_rect, COLOR_BLUE, 2.); + let mut color = text_color.clone(); + if glyph.sprite.has_color { + color = COLOR_WHITE; + } + mesh.draw_box(&glyph_rect, color, &uv_rect); + } + + let mesh = mesh.alloc(&render_api).await.unwrap(); + + TextRenderInfo { glyphs, mesh, texture_id: atlas.texture_id } + } + + async fn do_key_action(&self, key: &KeyCode, mods: &KeyMods) { + match key { + KeyCode::Left => {} + _ => self.insert_char(key, mods).await, + } + } + + async fn insert_char(&self, key: &KeyCode, mods: &KeyMods) { + // we could use a char but fuck the law + let Some(key) = keycode_to_string(key) else { + return; + }; + + // First filter for only single digit keys + let allowed_keys = [ + "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", + "R", "S", "T", "U", "V", "W", "X", "Y", "Z", " ", ":", ";", "'", "-", ".", "/", "=", + "(", "\\", ")", "`", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", + ]; + if !allowed_keys.contains(&key.as_str()) { + return + } + + // If we want to only allow specific chars in a String here + //let ch = key.chars().next().unwrap(); + // if !self.allowed_chars.chars().any(|c| c == ch) { return } + + let key = if mods.shift { key.to_string() } else { key.to_lowercase() }; + + self.insert_text(key).await; + } + + async fn insert_text(&self, key: String) { + let mut text = String::new(); + + let cursor_pos = self.cursor_pos.get(); + + let glyphs = self.render_info.lock().unwrap().glyphs.clone(); + + // We rebuild the string but insert our substr at cursor_pos. + // The substr is inserted before cursor_pos, and appending to the end + // of the string is when cursor_pos = len(str). + // We can't use String::insert() because sometimes multiple chars are combined + // into a single glyph. We treat the cursor pos as acting on the substrs + // themselves. + for (i, glyph) in glyphs.iter().enumerate() { + if cursor_pos == i as u32 { + text.push_str(&key); + } + text.push_str(&glyph.substr); + } + // Append to the end + if cursor_pos == glyphs.len() as u32 { + text.push_str(&key); + } + + self.text.set(text); + // Not always true lol + // If glyphs are recombined, this could get messed up + // meh lets pretend it doesn't exist for now. + self.cursor_pos.set(cursor_pos + 1); + + self.redraw().await; + } + + async fn redraw(&self) { + let old = self.render_info.lock().unwrap().clone(); + + let render_info = Self::regen_mesh( + &self.render_api, + &self.text_shaper, + self.text.get(), + self.font_size.get(), + self.text_color.get(), + self.baseline.get(), + self.debug.get(), + ) + .await; + *self.render_info.lock().unwrap() = render_info; + + let sg = self.sg.lock().await; + let node = sg.get_node(self.node_id).unwrap(); + + let Some(parent_rect) = get_parent_rect(&sg, node) else { + return; + }; + + let Some(draw_update) = self.draw(&sg, &parent_rect).await else { + error!(target: "ui::editbox", "Text {:?} failed to draw", node); + return; + }; + self.render_api.replace_draw_calls(draw_update.draw_calls).await; + debug!(target: "ui::editbox", "replace draw calls done"); + + // We're finished with these so clean up. + self.render_api.delete_buffer(old.mesh.vertex_buffer); + self.render_api.delete_buffer(old.mesh.index_buffer); + self.render_api.delete_texture(old.texture_id); + } + + pub async fn draw(&self, sg: &SceneGraph, parent_rect: &Rectangle) -> Option { + debug!(target: "ui::editbox", "EditBox::draw()"); + // Only used for debug messages + let node = sg.get_node(self.node_id).unwrap(); + + let render_info = self.render_info.lock().unwrap().clone(); + + let mesh = DrawMesh { + vertex_buffer: render_info.mesh.vertex_buffer, + index_buffer: render_info.mesh.index_buffer, + texture: Some(render_info.texture_id), + num_elements: render_info.mesh.num_elements, + }; + + if let Err(err) = eval_rect(self.rect.clone(), parent_rect) { + panic!("Node {:?} bad rect property: {}", node, err); + } + + let Ok(mut rect) = read_rect(self.rect.clone()) else { + panic!("Node {:?} bad rect property", node); + }; + + rect.x += parent_rect.x; + rect.y += parent_rect.x; + + let off_x = rect.x / parent_rect.w; + let off_y = rect.y / parent_rect.h; + let scale_x = 1. / parent_rect.w; + let scale_y = 1. / parent_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.)); + + Some(DrawUpdate { + key: self.dc_key, + draw_calls: vec![( + self.dc_key, + DrawCall { + instrs: vec![DrawInstruction::ApplyMatrix(model), DrawInstruction::Draw(mesh)], + dcs: vec![], + z_index: self.z_index.get(), + }, + )], + }) + } } +fn keycode_to_string(key: &KeyCode) -> Option { + match key { + KeyCode::Space => Some(" ".to_string()), + KeyCode::Apostrophe => Some("'".to_string()), + KeyCode::Comma => Some(",".to_string()), + KeyCode::Minus => Some("-".to_string()), + KeyCode::Period => Some(".".to_string()), + KeyCode::Slash => Some("/".to_string()), + KeyCode::Key0 => Some("0".to_string()), + KeyCode::Key1 => Some("1".to_string()), + KeyCode::Key2 => Some("2".to_string()), + KeyCode::Key3 => Some("3".to_string()), + KeyCode::Key4 => Some("4".to_string()), + KeyCode::Key5 => Some("5".to_string()), + KeyCode::Key6 => Some("6".to_string()), + KeyCode::Key7 => Some("7".to_string()), + KeyCode::Key8 => Some("8".to_string()), + KeyCode::Key9 => Some("9".to_string()), + KeyCode::Semicolon => Some(";".to_string()), + KeyCode::Equal => Some("=".to_string()), + KeyCode::A => Some("A".to_string()), + KeyCode::B => Some("B".to_string()), + KeyCode::C => Some("C".to_string()), + KeyCode::D => Some("D".to_string()), + KeyCode::E => Some("E".to_string()), + KeyCode::F => Some("F".to_string()), + KeyCode::G => Some("G".to_string()), + KeyCode::H => Some("H".to_string()), + KeyCode::I => Some("I".to_string()), + KeyCode::J => Some("J".to_string()), + KeyCode::K => Some("K".to_string()), + KeyCode::L => Some("L".to_string()), + KeyCode::M => Some("M".to_string()), + KeyCode::N => Some("N".to_string()), + KeyCode::O => Some("O".to_string()), + KeyCode::P => Some("P".to_string()), + KeyCode::Q => Some("Q".to_string()), + KeyCode::S => Some("S".to_string()), + KeyCode::T => Some("T".to_string()), + KeyCode::U => Some("U".to_string()), + KeyCode::V => Some("V".to_string()), + KeyCode::W => Some("W".to_string()), + KeyCode::X => Some("X".to_string()), + KeyCode::Y => Some("Y".to_string()), + KeyCode::Z => Some("Z".to_string()), + KeyCode::LeftBracket => Some("(".to_string()), + KeyCode::Backslash => Some("\\".to_string()), + KeyCode::RightBracket => Some(")".to_string()), + KeyCode::Kp0 => Some("0".to_string()), + KeyCode::Kp1 => Some("1".to_string()), + KeyCode::Kp2 => Some("2".to_string()), + KeyCode::Kp3 => Some("3".to_string()), + KeyCode::Kp4 => Some("4".to_string()), + KeyCode::Kp5 => Some("5".to_string()), + KeyCode::Kp6 => Some("6".to_string()), + KeyCode::Kp7 => Some("7".to_string()), + KeyCode::Kp8 => Some("8".to_string()), + KeyCode::Kp9 => Some("9".to_string()), + KeyCode::KpDecimal => Some(".".to_string()), + KeyCode::KpDivide => Some("/".to_string()), + KeyCode::KpMultiply => Some("*".to_string()), + KeyCode::KpSubtract => Some("-".to_string()), + _ => None, + } +} + +impl Stoppable for EditBox { + async fn stop(&self) { + // TODO: Delete own draw call + + // Free buffers + // Should this be in drop? + //self.render_api.delete_buffer(self.vertex_buffer); + //self.render_api.delete_buffer(self.index_buffer); + } +} diff --git a/bin/darkwallet/src/ui/layer.rs b/bin/darkwallet/src/ui/layer.rs index 8c8d35947..e37b79322 100644 --- a/bin/darkwallet/src/ui/layer.rs +++ b/bin/darkwallet/src/ui/layer.rs @@ -120,6 +120,7 @@ impl RenderLayer { Pimpl::RenderLayer(layer) => layer.draw(&sg, &rect).await, Pimpl::Mesh(mesh) => mesh.draw(&sg, &rect), Pimpl::Text(txt) => txt.draw(&sg, &rect).await, + Pimpl::EditBox(editb) => editb.draw(&sg, &rect).await, _ => { error!(target: "ui::layer", "unhandled pimpl type"); continue diff --git a/bin/darkwallet/src/ui/text.rs b/bin/darkwallet/src/ui/text.rs index 8532c93f7..eb3170dae 100644 --- a/bin/darkwallet/src/ui/text.rs +++ b/bin/darkwallet/src/ui/text.rs @@ -1,7 +1,7 @@ //use async_lock::Mutex; use miniquad::{BufferId, TextureId}; use rand::{rngs::OsRng, Rng}; -use std::sync::{Arc, Mutex, Weak}; +use std::sync::{Arc, Mutex as SyncMutex, Weak}; use crate::{ gfx2::{DrawCall, DrawInstruction, DrawMesh, Rectangle, RenderApi, RenderApiPtr, Vertex}, @@ -30,7 +30,7 @@ pub struct Text { text_shaper: TextShaperPtr, tasks: Vec>, - render_info: Mutex, + render_info: SyncMutex, dc_key: u64, node_id: SceneNodeId, @@ -38,7 +38,7 @@ pub struct Text { z_index: PropertyUint32, text: PropertyStr, font_size: PropertyFloat32, - color: PropertyColor, + text_color: PropertyColor, baseline: PropertyFloat32, debug: PropertyBool, } @@ -58,7 +58,7 @@ impl Text { let z_index = PropertyUint32::wrap(node, "z_index", 0).unwrap(); let text = PropertyStr::wrap(node, "text", 0).unwrap(); let font_size = PropertyFloat32::wrap(node, "font_size", 0).unwrap(); - let color = PropertyColor::wrap(node, "color").unwrap(); + let text_color = PropertyColor::wrap(node, "text_color").unwrap(); let baseline = PropertyFloat32::wrap(node, "baseline", 0).unwrap(); let debug = PropertyBool::wrap(node, "debug", 0).unwrap(); drop(scene_graph); @@ -68,7 +68,7 @@ impl Text { &text_shaper, text.get(), font_size.get(), - color.get(), + text_color.get(), baseline.get(), debug.get(), ) @@ -80,7 +80,7 @@ impl Text { on_modify.when_change(z_index.prop(), Self::redraw); on_modify.when_change(text.prop(), Self::redraw); on_modify.when_change(font_size.prop(), Self::redraw); - on_modify.when_change(color.prop(), Self::redraw); + on_modify.when_change(text_color.prop(), Self::redraw); on_modify.when_change(debug.prop(), Self::redraw); on_modify.when_change(baseline.prop(), Self::redraw); @@ -89,14 +89,14 @@ impl Text { render_api, text_shaper, tasks: on_modify.tasks, - render_info: Mutex::new(render_info), + render_info: SyncMutex::new(render_info), dc_key: OsRng.gen(), node_id, rect, z_index, text, font_size, - color, + text_color, baseline, debug, } @@ -146,17 +146,13 @@ impl Text { &self.text_shaper, self.text.get(), self.font_size.get(), - self.color.get(), + self.text_color.get(), self.baseline.get(), self.debug.get(), ) .await; *self.render_info.lock().unwrap() = render_info; - self.render_api.delete_buffer(old.mesh.vertex_buffer); - self.render_api.delete_buffer(old.mesh.index_buffer); - self.render_api.delete_texture(old.texture_id); - let sg = self.sg.lock().await; let node = sg.get_node(self.node_id).unwrap(); @@ -170,6 +166,11 @@ impl Text { }; self.render_api.replace_draw_calls(draw_update.draw_calls).await; debug!(target: "ui::text", "replace draw calls done"); + + // We're finished with these so clean up. + self.render_api.delete_buffer(old.mesh.vertex_buffer); + self.render_api.delete_buffer(old.mesh.index_buffer); + self.render_api.delete_texture(old.texture_id); } pub async fn draw(&self, sg: &SceneGraph, parent_rect: &Rectangle) -> Option { @@ -224,7 +225,12 @@ impl Stoppable for Text { // Free buffers // Should this be in drop? - //self.render_api.delete_buffer(self.vertex_buffer); - //self.render_api.delete_buffer(self.index_buffer); + let render_info = self.render_info.lock().unwrap().clone(); + let vertex_buffer = render_info.mesh.vertex_buffer; + let index_buffer = render_info.mesh.index_buffer; + let texture_id = render_info.texture_id; + self.render_api.delete_buffer(vertex_buffer); + self.render_api.delete_buffer(index_buffer); + self.render_api.delete_texture(texture_id); } }