diff --git a/bin/darkwallet/src/scene.rs b/bin/darkwallet/src/scene.rs
index 3caf4109f..da16348f4 100644
--- a/bin/darkwallet/src/scene.rs
+++ b/bin/darkwallet/src/scene.rs
@@ -471,6 +471,7 @@ pub enum Pimpl {
VectorArt(ui::VectorArtPtr),
Text(ui::TextPtr),
EditBox(ui::EditBoxPtr),
+ ChatEdit(ui::ChatEditPtr),
ChatView(ui::ChatViewPtr),
Image(ui::ImagePtr),
Button(ui::ButtonPtr),
diff --git a/bin/darkwallet/src/ui/chatedit.rs b/bin/darkwallet/src/ui/chatedit.rs
new file mode 100644
index 000000000..95bb5131f
--- /dev/null
+++ b/bin/darkwallet/src/ui/chatedit.rs
@@ -0,0 +1,1559 @@
+/* This file is part of DarkFi (https://dark.fi)
+ *
+ * Copyright (C) 2020-2024 Dyne.org foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ */
+
+use async_lock::Mutex as AsyncMutex;
+use async_trait::async_trait;
+use atomic_float::AtomicF32;
+use darkfi::system::msleep;
+use miniquad::{window, KeyCode, KeyMods, MouseButton, TouchPhase};
+use rand::{rngs::OsRng, Rng};
+use std::{
+ collections::HashMap,
+ sync::{
+ atomic::{AtomicBool, Ordering},
+ Arc, Mutex as SyncMutex, OnceLock, Weak,
+ },
+ time::Instant,
+};
+
+use crate::{
+ error::Result,
+ gfx::{
+ GfxDrawCall, GfxDrawInstruction, GfxDrawMesh, GfxTextureId, GraphicsEventPublisherPtr,
+ Point, Rectangle, RenderApi, Vertex,
+ },
+ mesh::{MeshBuilder, MeshInfo, COLOR_BLUE, COLOR_WHITE},
+ prop::{
+ PropertyBool, PropertyColor, PropertyFloat32, PropertyPtr, PropertyRect, PropertyStr,
+ PropertyUint32, Role,
+ },
+ pubsub::Subscription,
+ scene::{Pimpl, SceneNodePtr, SceneNodeWeak},
+ text::{self, Glyph, GlyphPositionIter, TextShaperPtr},
+ util::{enumerate_ref, is_whitespace, zip3},
+ ExecutorPtr,
+};
+
+use super::{
+ editbox::{
+ editable::{Editable, Selection, TextIdx, TextPos},
+ eol_nudge,
+ repeat::{PressedKey, PressedKeysSmoothRepeat},
+ ALLOWED_KEYCODES, DISALLOWED_CHARS,
+ },
+ DrawUpdate, OnModify, UIObject,
+};
+
+#[derive(Clone)]
+struct TouchStartInfo {
+ pos: Point,
+ instant: std::time::Instant,
+}
+
+impl TouchStartInfo {
+ fn new(pos: Point) -> Self {
+ Self { pos, instant: std::time::Instant::now() }
+ }
+}
+
+#[derive(Clone)]
+enum TouchStateAction {
+ Inactive,
+ Started { pos: Point, instant: std::time::Instant },
+ StartSelect,
+ Select,
+ DragSelectHandle { side: isize },
+ ScrollHoriz { start_pos: Point, scroll_start: f32 },
+}
+
+struct TouchInfo {
+ state: TouchStateAction,
+ start: Option,
+
+ scroll: PropertyFloat32,
+}
+
+impl TouchInfo {
+ fn new(scroll: PropertyFloat32) -> Self {
+ Self { state: TouchStateAction::Inactive, start: None, scroll }
+ }
+
+ fn start(&mut self, pos: Point) {
+ debug!(target: "ui::chatedit", "TouchStateAction::Started");
+ self.state = TouchStateAction::Started { pos, instant: std::time::Instant::now() };
+ }
+
+ fn stop(&mut self) -> TouchStateAction {
+ std::mem::replace(&mut self.state, TouchStateAction::Inactive)
+ }
+
+ fn update(&mut self, pos: &Point) {
+ match &self.state {
+ TouchStateAction::Started { pos: start_pos, instant } => {
+ let travel_dist = pos.dist_sq(&start_pos);
+ let x_dist = pos.x - start_pos.x;
+ let elapsed = instant.elapsed().as_millis();
+
+ if travel_dist < 5. {
+ if elapsed > 1000 {
+ debug!(target: "ui::chatedit", "TouchStateAction::StartSelect");
+ self.state = TouchStateAction::StartSelect;
+ }
+ } else if x_dist.abs() > 5. {
+ debug!(target: "ui::chatedit", "TouchStateAction::ScrollHoriz");
+ let scroll_start = self.scroll.get();
+ self.state =
+ TouchStateAction::ScrollHoriz { start_pos: *start_pos, scroll_start };
+ }
+ }
+ _ => {}
+ }
+ }
+}
+
+pub type ChatEditPtr = Arc;
+
+pub struct ChatEdit {
+ node: SceneNodeWeak,
+ tasks: OnceLock>>,
+ render_api: RenderApi,
+ text_shaper: TextShaperPtr,
+ key_repeat: SyncMutex,
+
+ glyphs: SyncMutex>,
+ /// DC key for the text
+ text_dc_key: u64,
+ cursor_mesh: SyncMutex>,
+ /// DC key for the cursor. Allows updating cursor independently.
+ cursor_dc_key: u64,
+
+ is_active: PropertyBool,
+ is_focused: PropertyBool,
+ rect: PropertyRect,
+ baseline: PropertyFloat32,
+ scroll: PropertyFloat32,
+ scroll_speed: PropertyFloat32,
+ cursor_pos: PropertyUint32,
+ font_size: PropertyFloat32,
+ text: PropertyStr,
+ text_color: PropertyColor,
+ text_hi_color: PropertyColor,
+ cursor_color: PropertyColor,
+ cursor_width: PropertyFloat32,
+ cursor_ascent: PropertyFloat32,
+ cursor_descent: PropertyFloat32,
+ cursor_blink_time: PropertyUint32,
+ cursor_idle_time: PropertyUint32,
+ hi_bg_color: PropertyColor,
+ select_ascent: PropertyFloat32,
+ select_descent: PropertyFloat32,
+ selected: PropertyPtr,
+ z_index: PropertyUint32,
+ debug: PropertyBool,
+
+ editable: SyncMutex,
+ select: SyncMutex>,
+
+ mouse_btn_held: AtomicBool,
+ cursor_is_visible: AtomicBool,
+ blink_is_paused: AtomicBool,
+ /// Used to explicitly hide the cursor. Must be manually re-enabled.
+ hide_cursor: AtomicBool,
+
+ touch_info: SyncMutex,
+ is_phone_select: AtomicBool,
+
+ old_window_scale: AtomicF32,
+ window_scale: PropertyFloat32,
+ parent_rect: SyncMutex>,
+ is_mouse_hover: AtomicBool,
+}
+
+impl ChatEdit {
+ pub async fn new(
+ node: SceneNodeWeak,
+ window_scale: PropertyFloat32,
+ render_api: RenderApi,
+ text_shaper: TextShaperPtr,
+ ex: ExecutorPtr,
+ ) -> Pimpl {
+ debug!(target: "ui::chatedit", "EditBox::new()");
+
+ let node_ref = &node.upgrade().unwrap();
+ let is_active = PropertyBool::wrap(node_ref, Role::Internal, "is_active", 0).unwrap();
+ let is_focused = PropertyBool::wrap(node_ref, Role::Internal, "is_focused", 0).unwrap();
+ let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
+ let baseline = PropertyFloat32::wrap(node_ref, Role::Internal, "baseline", 0).unwrap();
+ let scroll = PropertyFloat32::wrap(node_ref, Role::Internal, "scroll", 0).unwrap();
+ let scroll_speed =
+ PropertyFloat32::wrap(node_ref, Role::Internal, "scroll_speed", 0).unwrap();
+ let cursor_pos = PropertyUint32::wrap(node_ref, Role::Internal, "cursor_pos", 0).unwrap();
+ let font_size = PropertyFloat32::wrap(node_ref, Role::Internal, "font_size", 0).unwrap();
+ let text = PropertyStr::wrap(node_ref, Role::Internal, "text", 0).unwrap();
+ let text_color = PropertyColor::wrap(node_ref, Role::Internal, "text_color").unwrap();
+ let text_hi_color = PropertyColor::wrap(node_ref, Role::Internal, "text_hi_color").unwrap();
+ let cursor_color = PropertyColor::wrap(node_ref, Role::Internal, "cursor_color").unwrap();
+ let cursor_width =
+ PropertyFloat32::wrap(node_ref, Role::Internal, "cursor_width", 0).unwrap();
+ let cursor_ascent =
+ PropertyFloat32::wrap(node_ref, Role::Internal, "cursor_ascent", 0).unwrap();
+ let cursor_descent =
+ PropertyFloat32::wrap(node_ref, Role::Internal, "cursor_descent", 0).unwrap();
+ let hi_bg_color = PropertyColor::wrap(node_ref, Role::Internal, "hi_bg_color").unwrap();
+ let select_ascent =
+ PropertyFloat32::wrap(node_ref, Role::Internal, "select_ascent", 0).unwrap();
+ let select_descent =
+ PropertyFloat32::wrap(node_ref, Role::Internal, "select_descent", 0).unwrap();
+ let selected = node_ref.get_property("selected").unwrap();
+ let cursor_blink_time =
+ PropertyUint32::wrap(node_ref, Role::Internal, "cursor_blink_time", 0).unwrap();
+ let cursor_idle_time =
+ PropertyUint32::wrap(node_ref, Role::Internal, "cursor_idle_time", 0).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 node_name = node_ref.name.clone();
+ let node_id = node_ref.id;
+
+ // Must do this whenever the text changes
+ let glyphs = text_shaper.shape(text.get(), font_size.get(), window_scale.get());
+
+ let self_ = Arc::new(Self {
+ node,
+ tasks: OnceLock::new(),
+ render_api,
+ text_shaper: text_shaper.clone(),
+ key_repeat: SyncMutex::new(PressedKeysSmoothRepeat::new(400, 50)),
+
+ glyphs: SyncMutex::new(glyphs),
+ text_dc_key: OsRng.gen(),
+ cursor_mesh: SyncMutex::new(None),
+ cursor_dc_key: OsRng.gen(),
+
+ is_active,
+ is_focused,
+ rect,
+ baseline: baseline.clone(),
+ scroll: scroll.clone(),
+ scroll_speed,
+ cursor_pos,
+ font_size: font_size.clone(),
+ text,
+ text_color,
+ text_hi_color,
+ cursor_color,
+ cursor_width,
+ cursor_ascent,
+ cursor_descent,
+ cursor_blink_time,
+ cursor_idle_time,
+ hi_bg_color,
+ select_ascent,
+ select_descent,
+ selected,
+ z_index,
+ debug,
+
+ editable: SyncMutex::new(Editable::new(
+ text_shaper,
+ font_size,
+ window_scale.clone(),
+ baseline,
+ )),
+ select: SyncMutex::new(vec![]),
+
+ mouse_btn_held: AtomicBool::new(false),
+ cursor_is_visible: AtomicBool::new(true),
+ blink_is_paused: AtomicBool::new(false),
+ hide_cursor: AtomicBool::new(false),
+
+ touch_info: SyncMutex::new(TouchInfo::new(scroll)),
+ is_phone_select: AtomicBool::new(false),
+
+ old_window_scale: AtomicF32::new(window_scale.get()),
+ window_scale,
+ parent_rect: SyncMutex::new(None),
+ is_mouse_hover: AtomicBool::new(false),
+ });
+
+ Pimpl::ChatEdit(self_)
+ }
+
+ fn node(&self) -> SceneNodePtr {
+ self.node.upgrade().unwrap()
+ }
+
+ /// Called whenever the text or any text property changes.
+ fn regen_text_mesh(&self, mut clip: Rectangle) -> GfxDrawMesh {
+ clip.x = 0.;
+ clip.y = 0.;
+
+ let is_focused = self.is_focused.get();
+ let text = self.text.get();
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let text_color = self.text_color.get();
+ let text_hi_color = self.text_hi_color.get();
+ let baseline = self.baseline.get();
+ let scroll = self.scroll.get();
+ let cursor_pos = self.cursor_pos.get() as usize;
+ let cursor_color = self.cursor_color.get();
+ let debug = self.debug.get();
+ //debug!(target: "ui::chatedit", "Rendering text '{text}' clip={clip:?}");
+ //debug!(target: "ui::chatedit", " cursor_pos={cursor_pos}, is_focused={is_focused}");
+
+ let rendered = self.editable.lock().unwrap().render();
+ let atlas = text::make_texture_atlas(&self.render_api, &rendered.glyphs);
+
+ let mut mesh = MeshBuilder::with_clip(clip.clone());
+
+ let selections = self.select.lock().unwrap().clone();
+ // Just an assert
+ if self.is_phone_select.load(Ordering::Relaxed) {
+ assert!(selections.len() <= 1);
+ }
+ for select in &selections {
+ self.draw_selected(&mut mesh, select, &rendered.glyphs, clip.h);
+ }
+ let select_marks = self.mark_selected_glyphs(&rendered.glyphs, selections);
+
+ if rendered.has_underline() {
+ self.draw_underline(
+ &mut mesh,
+ &rendered.glyphs,
+ clip.h,
+ rendered.under_start,
+ rendered.under_end,
+ );
+ }
+
+ let glyph_pos_iter =
+ GlyphPositionIter::new(font_size, window_scale, &rendered.glyphs, baseline);
+
+ for (glyph_idx, mut glyph_rect, glyph, is_selected) in
+ zip3(glyph_pos_iter, rendered.glyphs.iter(), select_marks.iter())
+ {
+ let uv_rect = atlas.fetch_uv(glyph.glyph_id).expect("missing glyph UV rect");
+
+ glyph_rect.x -= scroll;
+
+ //mesh.draw_outline(&glyph_rect, COLOR_BLUE, 2.);
+ let mut color = text_color.clone();
+ if *is_selected {
+ color = text_hi_color.clone();
+ }
+ if glyph.sprite.has_color {
+ color = COLOR_WHITE;
+ }
+ mesh.draw_box(&glyph_rect, color, uv_rect);
+ }
+
+ if debug {
+ mesh.draw_outline(&clip, COLOR_BLUE, 1.);
+ }
+
+ mesh.alloc(&self.render_api).draw_with_texture(atlas.texture)
+ }
+
+ fn regen_cursor_mesh(&self) -> GfxDrawMesh {
+ let cursor_width = self.cursor_width.get();
+ let cursor_ascent = self.cursor_ascent.get();
+ let cursor_descent = self.cursor_descent.get();
+ let baseline = self.baseline.get();
+
+ let cursor_rect = Rectangle {
+ x: 0.,
+ y: baseline - cursor_ascent,
+ w: cursor_width,
+ h: cursor_ascent + cursor_descent,
+ };
+ let cursor_color = self.cursor_color.get();
+
+ let mut mesh = MeshBuilder::new();
+ mesh.draw_filled_box(&cursor_rect, cursor_color);
+ mesh.alloc(&self.render_api).draw_untextured()
+ }
+
+ fn cursor_px_offset(&self) -> f32 {
+ assert!(self.is_focused.get());
+
+ let (cursor_pos, glyphs) = {
+ let editable = self.editable.lock().unwrap();
+ let rendered = editable.render();
+ let cursor_pos = editable.get_cursor_pos(&rendered);
+ (cursor_pos, rendered.glyphs)
+ };
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+ let scroll = self.scroll.get();
+ // Add composer glyphs too
+ let glyph_pos_iter = GlyphPositionIter::new(font_size, window_scale, &glyphs, baseline);
+ // Used for drawing the cursor when it's at the end of the line.
+ let mut rhs = 0.;
+
+ if cursor_pos == 0 {
+ return 0.;
+ }
+
+ for (glyph_idx, (mut glyph_rect, glyph)) in glyph_pos_iter.zip(glyphs.iter()).enumerate() {
+ glyph_rect.x -= scroll;
+
+ if cursor_pos == glyph_idx {
+ return glyph_rect.x;
+ }
+
+ rhs = glyph_rect.rhs();
+ }
+
+ assert!(cursor_pos == glyphs.len());
+
+ rhs += eol_nudge(font_size, &glyphs);
+ rhs
+ }
+
+ fn mark_selected_glyphs(&self, glyphs: &Vec, selections: Vec) -> Vec {
+ let mut marks: Vec<_> = glyphs.iter().map(|_| false).collect();
+ for select in selections {
+ let start = std::cmp::min(select.start, select.end);
+ let end = std::cmp::max(select.start, select.end);
+
+ for i in start..end {
+ marks[i] = true;
+ }
+ }
+ marks
+ }
+
+ fn draw_selected(
+ &self,
+ mesh: &mut MeshBuilder,
+ select: &Selection,
+ glyphs: &Vec,
+ clip_h: f32,
+ ) {
+ if select.start == select.end {
+ return
+ }
+ let start = std::cmp::min(select.start, select.end);
+ let end = std::cmp::max(select.start, select.end);
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+ let scroll = self.scroll.get();
+ let hi_bg_color = self.hi_bg_color.get();
+ let glyph_pos_iter = GlyphPositionIter::new(font_size, window_scale, &glyphs, baseline);
+
+ let is_phone_select = self.is_phone_select.load(Ordering::Relaxed);
+
+ let mut start_x = 0.;
+ let mut end_x = 0.;
+ // When cursor lands at the end of the line
+ let mut rhs = 0.;
+
+ for (glyph_idx, mut glyph_rect) in glyph_pos_iter.enumerate() {
+ glyph_rect.x -= scroll;
+
+ if glyph_idx == start {
+ start_x = glyph_rect.x;
+ }
+ if glyph_idx == end {
+ end_x = glyph_rect.x;
+ }
+
+ rhs = glyph_rect.rhs();
+ }
+
+ if start == 0 {
+ start_x = scroll;
+ }
+
+ if end == glyphs.len() {
+ rhs += eol_nudge(font_size, &glyphs);
+ end_x = rhs;
+ }
+
+ let select_ascent = self.select_ascent.get();
+ let select_descent = self.select_descent.get();
+
+ let select_rect = Rectangle {
+ x: start_x,
+ y: baseline - select_ascent,
+ w: end_x - start_x,
+ h: select_ascent + select_descent,
+ };
+ mesh.draw_box(&select_rect, hi_bg_color, &Rectangle::zero());
+
+ if is_phone_select {
+ self.draw_phone_select_handle(mesh, start_x, -1.);
+ self.draw_phone_select_handle(mesh, end_x, 1.);
+ }
+ }
+
+ fn draw_phone_select_handle(&self, mesh: &mut MeshBuilder, x: f32, side: f32) {
+ debug!(target: "ui::chatedit", "draw_phone_select_handle(..., {x}, {side})");
+
+ let baseline = self.baseline.get();
+ let select_ascent = self.select_ascent.get();
+ let select_descent = self.select_descent.get();
+ let color = self.text_hi_color.get();
+ // Transparent for fade
+ let mut color_trans = color.clone();
+ color_trans[3] = 0.;
+
+ // Vertical line downwards. We use this instead of draw_box() so we have a fade.
+ let verts = vec![
+ Vertex {
+ pos: [x - side * 1., baseline - select_ascent],
+ color: color_trans,
+ uv: [0., 0.],
+ },
+ Vertex {
+ pos: [x + side * 4., baseline - select_ascent],
+ color: color_trans,
+ uv: [0., 0.],
+ },
+ Vertex { pos: [x - side * 1., baseline + select_descent + 5.], color, uv: [0., 0.] },
+ Vertex { pos: [x + side * 4., baseline + select_descent + 5.], color, uv: [0., 0.] },
+ ];
+ let indices = vec![0, 2, 1, 1, 2, 3];
+ mesh.append(verts, indices);
+
+ let y = baseline + select_descent;
+
+ // The arrow itself.
+ // Go anti-clockwise
+ let verts = vec![
+ Vertex { pos: [x, y], color, uv: [0., 0.] },
+ Vertex { pos: [x, y + 50.], color, uv: [0., 0.] },
+ Vertex { pos: [x + side * 30., y + 50.], color, uv: [0., 0.] },
+ Vertex { pos: [x + side * 50., y + 25.], color, uv: [0., 0.] },
+ ];
+ let indices = vec![0, 1, 2, 0, 2, 3];
+ mesh.append(verts, indices);
+ }
+
+ fn draw_underline(
+ &self,
+ mesh: &mut MeshBuilder,
+ glyphs: &Vec,
+ clip_h: f32,
+ under_start: usize,
+ under_end: usize,
+ ) {
+ assert!(under_start < under_end);
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+ let scroll = self.scroll.get();
+ let text_color = self.text_color.get();
+ let glyph_pos_iter = GlyphPositionIter::new(font_size, window_scale, &glyphs, baseline);
+
+ let mut start_x = 0.;
+ let mut end_x = 0.;
+ // When cursor lands at the end of the line
+ let mut rhs = 0.;
+
+ for (glyph_idx, mut glyph_rect) in glyph_pos_iter.enumerate() {
+ glyph_rect.x -= scroll;
+
+ if glyph_idx == under_start {
+ start_x = glyph_rect.x;
+ }
+ if glyph_idx == under_end {
+ end_x = glyph_rect.x;
+ }
+
+ rhs = glyph_rect.rhs();
+ }
+
+ if under_start == 0 {
+ start_x = scroll;
+ }
+
+ if under_end == glyphs.len() {
+ end_x = rhs;
+ }
+
+ // We don't need to do manual clipping since MeshBuilder should do that
+ let underline_rect = Rectangle { x: start_x, y: baseline + 6., w: end_x - start_x, h: 4. };
+ mesh.draw_box(&underline_rect, text_color, &Rectangle::zero());
+ }
+
+ async fn change_focus(self: Arc) {
+ if !self.is_active.get() {
+ return
+ }
+ debug!(target: "ui::chatedit", "Focus changed");
+
+ // Cursor visibility will change so just redraw everything lol
+ self.redraw().await;
+ }
+
+ async fn insert_char(&self, key: char) {
+ {
+ let mut editable = self.editable.lock().unwrap();
+ let mut tmp = [0; 4];
+ let key_str = key.encode_utf8(&mut tmp);
+ editable.compose(key_str, true);
+ }
+
+ self.pause_blinking();
+ self.redraw().await;
+ }
+
+ async fn handle_shortcut(&self, key: char, mods: &KeyMods) {
+ debug!(target: "ui::chatedit", "handle_shortcut({:?}, {:?})", key, mods);
+
+ match key {
+ 'c' => {
+ if mods.ctrl {
+ self.copy_highlighted().unwrap();
+ }
+ }
+ 'v' => {
+ if mods.ctrl {
+ if let Some(text) = window::clipboard_get() {
+ self.paste_text(text).await;
+ }
+ }
+ }
+ _ => {}
+ }
+ }
+
+ async fn handle_key(&self, key: &KeyCode, mods: &KeyMods) {
+ debug!(target: "ui::chatedit", "handle_key({:?}, {:?})", key, mods);
+ match key {
+ KeyCode::Left => {
+ self.adjust_cursor(mods.shift, |editable| editable.move_cursor(-1));
+ self.pause_blinking();
+ //self.apply_cursor_scrolling();
+ self.redraw().await;
+ }
+ KeyCode::Right => {
+ self.adjust_cursor(mods.shift, |editable| editable.move_cursor(1));
+ self.pause_blinking();
+ //self.apply_cursor_scrolling();
+ self.redraw().await;
+ }
+ KeyCode::Kp0 => self.insert_char('0').await,
+ KeyCode::Kp1 => self.insert_char('1').await,
+ KeyCode::Kp2 => self.insert_char('2').await,
+ KeyCode::Kp3 => self.insert_char('3').await,
+ KeyCode::Kp4 => self.insert_char('4').await,
+ KeyCode::Kp5 => self.insert_char('5').await,
+ KeyCode::Kp6 => self.insert_char('6').await,
+ KeyCode::Kp7 => self.insert_char('7').await,
+ KeyCode::Kp8 => self.insert_char('8').await,
+ KeyCode::Kp9 => self.insert_char('9').await,
+ KeyCode::KpDecimal => self.insert_char('.').await,
+ KeyCode::Enter | KeyCode::KpEnter => {
+ let node = self.node.upgrade().unwrap();
+ node.trigger("enter_pressed", vec![]).await.unwrap();
+ }
+ KeyCode::Delete => {
+ self.delete(0, 1);
+ self.clamp_scroll();
+ self.pause_blinking();
+ self.redraw().await;
+ }
+ KeyCode::Backspace => {
+ self.delete(1, 0);
+ self.clamp_scroll();
+ self.pause_blinking();
+ self.redraw().await;
+ }
+ KeyCode::Home => {
+ self.adjust_cursor(mods.shift, |editable| editable.move_start());
+ self.pause_blinking();
+ //self.apply_cursor_scrolling();
+ self.redraw().await;
+ }
+ KeyCode::End => {
+ self.adjust_cursor(mods.shift, |editable| editable.move_end());
+ self.pause_blinking();
+ //self.apply_cursor_scrolling();
+ self.redraw().await;
+ }
+ _ => {}
+ }
+ }
+
+ fn delete(&self, before: usize, after: usize) {
+ let mut editable = self.editable.lock().unwrap();
+ let selection = std::mem::take(&mut *self.select.lock().unwrap());
+
+ if selection.is_empty() {
+ editable.delete(before, after);
+ return
+ }
+
+ let sel = selection.first().unwrap();
+ let cursor_pos = std::cmp::min(sel.start, sel.end);
+
+ let render = editable.render();
+ let mut before_text = String::new();
+ let mut after_text = String::new();
+ 'next: for (pos, glyph) in render.glyphs.iter().enumerate() {
+ for select in &selection {
+ let start = std::cmp::min(select.start, select.end);
+ let end = std::cmp::max(select.start, select.end);
+
+ if start <= pos && pos < end {
+ continue 'next
+ }
+ }
+ if pos <= cursor_pos {
+ before_text += &glyph.substr;
+ } else {
+ after_text += &glyph.substr;
+ }
+ }
+
+ editable.set_text(before_text, after_text);
+
+ self.is_phone_select.store(false, Ordering::Relaxed);
+ // Reshow cursor (if hidden)
+ self.hide_cursor.store(false, Ordering::Relaxed);
+ }
+
+ fn adjust_cursor(&self, has_shift: bool, move_cursor: impl Fn(&mut Editable)) {
+ let mut editable = self.editable.lock().unwrap();
+ let rendered = editable.render();
+ let prev_cursor_pos = editable.get_cursor_pos(&rendered);
+ move_cursor(&mut editable);
+ let cursor_pos = editable.get_cursor_pos(&rendered);
+ drop(editable);
+
+ let mut select = self.select.lock().unwrap();
+
+ // Start selection if shift is held
+ if has_shift {
+ // Create a new selection
+ if select.is_empty() {
+ select.push(Selection::new(prev_cursor_pos, cursor_pos));
+ }
+
+ // Update the selection
+ select.last_mut().unwrap().end = cursor_pos;
+ } else {
+ select.clear();
+ }
+ }
+
+ /// This will select the entire word rather than move the cursor to that location
+ fn start_touch_select(&self, x: f32) {
+ let rect = self.rect.get();
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+
+ {
+ let mut editable = self.editable.lock().unwrap();
+ editable.end_compose();
+
+ let rendered = editable.render();
+ let x = x - rect.x + self.scroll.get();
+
+ let cpos = rendered.x_to_pos(x, font_size, window_scale, baseline);
+
+ // Find word start
+ let mut cpos_start = cpos;
+ while cpos_start > 0 {
+ // Is the glyph before this pos just whitespace?
+ let glyph_str = &rendered.glyphs[cpos_start - 1].substr;
+ if is_whitespace(glyph_str) {
+ break
+ }
+ cpos_start -= 1;
+ }
+ // Find word end
+ let mut cpos_end = cpos;
+ while cpos_end < rendered.glyphs.len() {
+ cpos_end += 1;
+ let glyph_str = &rendered.glyphs[cpos_end].substr;
+ if is_whitespace(glyph_str) {
+ break
+ }
+ }
+
+ let cidx_start = rendered.pos_to_idx(cpos_start);
+ let cidx_end = rendered.pos_to_idx(cpos_end);
+
+ // begin selection
+ let mut select = self.select.lock().unwrap();
+ select.clear();
+ select.push(Selection::new(cpos_start, cpos_end));
+ }
+
+ self.is_phone_select.store(true, Ordering::Relaxed);
+ // redraw() will now hide the cursor
+ self.hide_cursor.store(true, Ordering::Relaxed);
+ }
+
+ fn glyphs_to_string(glyphs: &Vec) -> String {
+ let mut text = String::new();
+ for (i, glyph) in glyphs.iter().enumerate() {
+ text.push_str(&glyph.substr);
+ }
+ text
+ }
+
+ fn delete_highlighted(&self) {
+ assert!(!self.selected.is_null(0).unwrap());
+ assert!(!self.selected.is_null(1).unwrap());
+
+ let start = self.selected.get_u32(0).unwrap() as usize;
+ let end = self.selected.get_u32(1).unwrap() as usize;
+
+ let sel_start = std::cmp::min(start, end);
+ let sel_end = std::cmp::max(start, end);
+
+ let mut glyphs = self.glyphs.lock().unwrap().clone();
+ glyphs.drain(sel_start..sel_end);
+
+ let text = Self::glyphs_to_string(&glyphs);
+ debug!(
+ target: "ui::chatedit",
+ "delete_highlighted() text=\"{}\", cursor_pos={}",
+ text, sel_start
+ );
+ self.text.set(text);
+
+ self.selected.set_null(Role::Internal, 0).unwrap();
+ self.selected.set_null(Role::Internal, 1).unwrap();
+ self.cursor_pos.set(sel_start as u32);
+ }
+
+ fn copy_highlighted(&self) -> Result<()> {
+ let start = self.selected.get_u32(0)? as usize;
+ let end = self.selected.get_u32(1)? as usize;
+
+ let sel_start = std::cmp::min(start, end);
+ let sel_end = std::cmp::max(start, end);
+
+ let mut text = String::new();
+
+ let glyphs = self.glyphs.lock().unwrap().clone();
+ for (glyph_idx, glyph) in glyphs.iter().enumerate() {
+ if sel_start <= glyph_idx && glyph_idx < sel_end {
+ text.push_str(&glyph.substr);
+ }
+ }
+
+ info!(target: "ui::chatedit", "Copied '{}'", text);
+ window::clipboard_set(&text);
+ Ok(())
+ }
+
+ async fn paste_text(&self, key: String) {
+ let mut text = String::new();
+
+ let cursor_pos = self.cursor_pos.get();
+
+ if cursor_pos == 0 {
+ text = key.clone();
+ }
+
+ let glyphs = self.glyphs.lock().unwrap().clone();
+ for (glyph_idx, glyph) in glyphs.iter().enumerate() {
+ text.push_str(&glyph.substr);
+ if cursor_pos == glyph_idx as u32 + 1 {
+ text.push_str(&key);
+ }
+ }
+
+ self.text.set(text);
+ // Not always true lol
+ self.cursor_pos.set(cursor_pos + 1);
+
+ self.apply_cursor_scrolling();
+ self.redraw().await;
+ }
+
+ async fn handle_touch_start(&self, pos: Point) -> bool {
+ debug!(target: "ui::chatedit", "handle_touch_start({pos:?})");
+ let mut touch_info = self.touch_info.lock().unwrap();
+
+ if self.try_handle_drag(&mut touch_info, pos) {
+ return true
+ }
+
+ let rect = self.rect.get();
+ if !rect.contains(pos) {}
+
+ touch_info.start(pos);
+ true
+ }
+ fn try_handle_drag(&self, touch_info: &mut TouchInfo, pos: Point) -> bool {
+ let selections = self.select.lock().unwrap().clone();
+
+ if self.is_phone_select.load(Ordering::Relaxed) && selections.len() == 1 {
+ let select = selections.first().unwrap();
+
+ let rendered = {
+ let editable = self.editable.lock().unwrap();
+ editable.render()
+ };
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+
+ // Get left handle centerpoint
+ let x1 = rendered.pos_to_xw(select.start, font_size, window_scale, baseline).0;
+ // Get right handle centerpoint
+ let x2 = {
+ let (x, w) = rendered.pos_to_xw(select.end, font_size, window_scale, baseline);
+ x + w
+ };
+
+ // Are we within range of either one?
+ let select_descent = self.select_descent.get();
+ let scroll = self.scroll.get();
+ let y = baseline + select_descent + 25.;
+
+ let p1 = Point::new(x1 - scroll, y);
+ let p2 = Point::new(x2 - scroll, y);
+ debug!(target: "ui::chatedit", "handle center points = ({p1:?}, {p2:?})");
+
+ const TOUCH_RADIUS_SQ: f32 = 10_000.;
+ // Make pos relative to the rect
+ let pos_rel = pos - self.rect.get().pos();
+
+ if p1.dist_sq(&pos_rel) <= TOUCH_RADIUS_SQ {
+ debug!(target: "ui::chatedit", "TouchStateAction::DragSelectHandle [side=-1]");
+ // Set touch_state status to enable begin dragging them
+ touch_info.state = TouchStateAction::DragSelectHandle { side: -1 };
+ return true;
+ }
+ if p2.dist_sq(&pos_rel) <= TOUCH_RADIUS_SQ {
+ debug!(target: "ui::chatedit", "TouchStateAction::DragSelectHandle [side=1]");
+ // Set touch_state status to enable begin dragging them
+ touch_info.state = TouchStateAction::DragSelectHandle { side: 1 };
+ return true;
+ }
+ }
+
+ false
+ }
+
+ async fn handle_touch_move(&self, pos: Point) -> bool {
+ //debug!(target: "ui::chatedit", "handle_touch_move({pos:?})");
+ let touch_state = {
+ let mut touch_info = self.touch_info.lock().unwrap();
+ touch_info.update(&pos);
+ touch_info.state.clone()
+ };
+ match &touch_state {
+ TouchStateAction::Inactive => return false,
+ TouchStateAction::StartSelect => {
+ let x = pos.x;
+ self.start_touch_select(x);
+ self.redraw().await;
+ debug!(target: "ui::chatedit", "TouchStateAction::Select");
+ self.touch_info.lock().unwrap().state = TouchStateAction::Select;
+ }
+ TouchStateAction::DragSelectHandle { side } => {
+ {
+ assert!(*side == -1 || *side == 1);
+ assert!(self.is_phone_select.load(Ordering::Relaxed));
+ let mut selections = self.select.lock().unwrap();
+ assert_eq!(selections.len(), 1);
+ let select = selections.first_mut().unwrap();
+
+ let rendered = {
+ let editable = self.editable.lock().unwrap();
+ editable.render()
+ };
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+
+ let pos_x = pos.x + self.scroll.get();
+
+ let mut pos = rendered.x_to_pos(pos_x, font_size, window_scale, baseline);
+ if *side == -1 {
+ let select_other_pos = &mut select.end;
+ if pos >= *select_other_pos {
+ pos = *select_other_pos - 1;
+ }
+ select.start = pos;
+ } else {
+ let select_other_pos = &mut select.start;
+ if pos <= *select_other_pos {
+ pos = *select_other_pos + 1;
+ }
+ select.end = pos;
+ }
+ }
+ self.redraw().await;
+ }
+ TouchStateAction::ScrollHoriz { start_pos, scroll_start } => {
+ let x_dist = start_pos.x - pos.x;
+ let mut scroll = scroll_start + x_dist;
+ scroll = scroll.clamp(0., self.max_cursor_scroll());
+ self.scroll.set(scroll);
+ self.redraw().await;
+ }
+ _ => {}
+ }
+ true
+ }
+ async fn handle_touch_end(&self, pos: Point) -> bool {
+ debug!(target: "ui::chatedit", "handle_touch_end({pos:?})");
+ let state = self.touch_info.lock().unwrap().stop();
+ match state {
+ TouchStateAction::Inactive => return false,
+ TouchStateAction::Started { pos: _, instant: _ } => {
+ let rect = self.rect.get();
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+
+ {
+ let mut editable = self.editable.lock().unwrap();
+ let rendered = editable.render();
+ // Adjust with scroll here too
+ let x = pos.x - rect.x;
+
+ let cpos = rendered.x_to_pos(x, font_size, window_scale, baseline);
+ let cidx = rendered.pos_to_idx(cpos);
+ editable.set_cursor_idx(cidx);
+
+ // begin selection
+ let mut select = self.select.lock().unwrap();
+ select.clear();
+ }
+
+ self.is_phone_select.store(false, Ordering::Relaxed);
+ // Reshow cursor (if hidden)
+ self.hide_cursor.store(false, Ordering::Relaxed);
+
+ self.redraw().await;
+ }
+ _ => {}
+ }
+ window::show_keyboard(true);
+ true
+ }
+
+ /// Whenever the cursor property is modified this MUST be called
+ /// to recalculate the scroll x property.
+ fn apply_cursor_scrolling(&self) {
+ let rect = self.rect.get();
+
+ let cursor_pos = self.cursor_pos.get() as usize;
+ let cursor_width = self.cursor_width.get();
+ let mut scroll = self.scroll.get();
+
+ let cursor_x = {
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+ let glyphs = self.glyphs.lock().unwrap().clone();
+
+ let mut glyph_pos_iter =
+ GlyphPositionIter::new(font_size, window_scale, &glyphs, baseline);
+
+ if cursor_pos == 0 {
+ 0.
+ } else if cursor_pos == glyphs.len() {
+ let glyph_pos = glyph_pos_iter.last().unwrap();
+
+ let rhs = glyph_pos.rhs() + eol_nudge(font_size, &glyphs);
+ rhs
+ } else {
+ assert!(cursor_pos < glyphs.len());
+ let glyph_pos = glyph_pos_iter.nth(cursor_pos).expect("glyph pos mismatch glyphs");
+ glyph_pos.x
+ }
+ };
+
+ // The LHS and RHS of the cursor box
+ let cursor_lhs = cursor_x - scroll;
+ let cursor_rhs = cursor_lhs + cursor_width;
+
+ // RHS is outside
+ if cursor_rhs > rect.w {
+ // We want a scroll so RHS = w
+ // cursor_x - scroll + CURSOR_WIDTH = rect.w
+ scroll = cursor_x + cursor_width - rect.w;
+ // LHS is negative
+ } else if cursor_lhs < 0. {
+ // We want scroll so LHS = 0
+ // cursor_x - scroll = 0
+ scroll = cursor_x;
+ }
+
+ self.scroll.set(scroll);
+ }
+
+ fn max_cursor_scroll(&self) -> f32 {
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+ let rhs = {
+ let mut editable = self.editable.lock().unwrap();
+ let rendered = editable.render();
+
+ if rendered.glyphs.is_empty() {
+ return 0.
+ }
+ let glyph_pos_iter =
+ GlyphPositionIter::new(font_size, window_scale, &rendered.glyphs, baseline);
+ let last_rect = glyph_pos_iter.last().unwrap();
+ let mut rhs = last_rect.x + last_rect.w;
+ rhs += eol_nudge(font_size, &rendered.glyphs);
+ rhs
+ };
+
+ let rect_w = self.rect.get().w;
+ if rhs <= rect_w {
+ return 0.;
+ }
+ let max_scroll = rhs - rect_w;
+ max_scroll
+ }
+
+ fn clamp_scroll(&self) {
+ let mut scroll = self.scroll.get();
+ scroll = scroll.clamp(0., self.max_cursor_scroll());
+ self.scroll.set(scroll);
+ }
+
+ fn pause_blinking(&self) {
+ self.blink_is_paused.store(true, Ordering::Relaxed);
+ self.cursor_is_visible.store(true, Ordering::Relaxed);
+ }
+
+ async fn redraw(&self) {
+ debug!(target: "ui::chatedit", "redraw()");
+
+ let parent_rect = self.parent_rect.lock().unwrap().unwrap().clone();
+ self.rect.eval(&parent_rect).expect("unable to eval rect");
+
+ let Some(draw_update) = self.make_draw_calls() else {
+ error!(target: "ui::chatedit", "Text failed to draw");
+ return;
+ };
+
+ self.render_api.replace_draw_calls(draw_update.draw_calls);
+ }
+
+ fn redraw_cursor(&self) {
+ let cursor_instrs = self.get_cursor_instrs();
+
+ let draw_calls = vec![(
+ self.cursor_dc_key,
+ GfxDrawCall { instrs: cursor_instrs, dcs: vec![], z_index: self.z_index.get() },
+ )];
+
+ self.render_api.replace_draw_calls(draw_calls);
+ }
+
+ fn get_cursor_instrs(&self) -> Vec {
+ if !self.is_focused.get() ||
+ !self.cursor_is_visible.load(Ordering::Relaxed) ||
+ self.hide_cursor.load(Ordering::Relaxed)
+ {
+ return vec![]
+ }
+
+ let mut cursor_instrs = vec![];
+
+ let rect_w = self.rect.get().w;
+
+ let mut cursor_pos = Point::zero();
+ cursor_pos.x += self.cursor_px_offset();
+ if cursor_pos.x > rect_w {
+ return vec![]
+ }
+ cursor_instrs.push(GfxDrawInstruction::Move(cursor_pos));
+
+ let cursor_mesh = {
+ let mut cursor_mesh = self.cursor_mesh.lock().unwrap();
+ if cursor_mesh.is_none() {
+ *cursor_mesh = Some(self.regen_cursor_mesh());
+ }
+ cursor_mesh.clone().unwrap()
+ };
+
+ cursor_instrs.push(GfxDrawInstruction::Draw(cursor_mesh));
+
+ cursor_instrs
+ }
+
+ fn make_draw_calls(&self) -> Option {
+ let rect = self.rect.get();
+
+ let text_mesh = self.regen_text_mesh(rect.clone());
+ let cursor_instrs = self.get_cursor_instrs();
+
+ Some(DrawUpdate {
+ key: self.text_dc_key,
+ draw_calls: vec![
+ (
+ self.text_dc_key,
+ GfxDrawCall {
+ instrs: vec![
+ GfxDrawInstruction::Move(rect.pos()),
+ GfxDrawInstruction::Draw(text_mesh),
+ ],
+ dcs: vec![self.cursor_dc_key],
+ z_index: self.z_index.get(),
+ },
+ ),
+ (
+ self.cursor_dc_key,
+ GfxDrawCall { instrs: cursor_instrs, dcs: vec![], z_index: self.z_index.get() },
+ ),
+ ],
+ })
+ }
+}
+
+impl Drop for ChatEdit {
+ fn drop(&mut self) {
+ self.render_api.replace_draw_calls(vec![(self.text_dc_key, Default::default())]);
+ }
+}
+
+#[async_trait]
+impl UIObject for ChatEdit {
+ fn z_index(&self) -> u32 {
+ self.z_index.get()
+ }
+
+ async fn start(self: Arc, ex: ExecutorPtr) {
+ let me = Arc::downgrade(&self);
+
+ let node_ref = &self.node.upgrade().unwrap();
+ let node_name = node_ref.name.clone();
+ let node_id = node_ref.id;
+
+ let mut on_modify = OnModify::new(ex.clone(), node_name, node_id, me.clone());
+ on_modify.when_change(self.is_focused.prop(), Self::change_focus);
+
+ // When text has been changed.
+ // Cursor and selection might be invalidated.
+ async fn reset(self_: Arc) {
+ self_.cursor_pos.set(0);
+ self_.selected.set_null(Role::Internal, 0).unwrap();
+ self_.selected.set_null(Role::Internal, 1).unwrap();
+ self_.scroll.set(0.);
+ self_.redraw();
+ }
+ async fn redraw(self_: Arc) {
+ self_.redraw().await;
+ }
+ on_modify.when_change(self.rect.prop(), redraw);
+ on_modify.when_change(self.baseline.prop(), redraw);
+ // The commented properties are modified on input events
+ // So then redraw() will get repeatedly triggered when these properties
+ // are changed. We should find a solution. For now the hooks are disabled.
+ //on_modify.when_change(scroll.prop(), redraw);
+ //on_modify.when_change(cursor_pos.prop(), redraw);
+ on_modify.when_change(self.font_size.prop(), redraw);
+ // We must also reshape text
+ on_modify.when_change(self.text.prop(), reset);
+ on_modify.when_change(self.text_color.prop(), redraw);
+ on_modify.when_change(self.hi_bg_color.prop(), redraw);
+ //on_modify.when_change(selected.clone(), redraw);
+ on_modify.when_change(self.z_index.prop(), redraw);
+ on_modify.when_change(self.debug.prop(), redraw);
+
+ async fn regen_cursor(self_: Arc) {
+ let mesh = std::mem::take(&mut *self_.cursor_mesh.lock().unwrap());
+ }
+ on_modify.when_change(self.cursor_color.prop(), regen_cursor);
+ on_modify.when_change(self.cursor_ascent.prop(), regen_cursor);
+ on_modify.when_change(self.cursor_descent.prop(), regen_cursor);
+ on_modify.when_change(self.cursor_width.prop(), regen_cursor);
+
+ let me2 = me.clone();
+ let cursor_blink_time = self.cursor_blink_time.clone();
+ let cursor_idle_time = self.cursor_idle_time.clone();
+ let blinking_cursor_task = ex.spawn(async move {
+ loop {
+ msleep(cursor_blink_time.get() as u64).await;
+
+ let self_ = me2.upgrade().unwrap();
+
+ if self_.blink_is_paused.swap(false, Ordering::Relaxed) {
+ msleep(cursor_idle_time.get() as u64).await;
+ continue
+ }
+
+ // Invert the bool
+ self_.cursor_is_visible.fetch_not(Ordering::Relaxed);
+ self_.redraw_cursor();
+ }
+ });
+
+ let mut tasks = on_modify.tasks;
+ tasks.push(blinking_cursor_task);
+ self.tasks.set(tasks);
+ }
+
+ async fn draw(&self, parent_rect: Rectangle) -> Option {
+ debug!(target: "ui::chatedit", "EditBox::draw()");
+ *self.parent_rect.lock().unwrap() = Some(parent_rect);
+ self.rect.eval(&parent_rect).ok()?;
+
+ self.clamp_scroll();
+ self.make_draw_calls()
+ }
+
+ async fn handle_char(&self, key: char, mods: KeyMods, repeat: bool) -> bool {
+ // First filter for only single digit keys
+ if DISALLOWED_CHARS.contains(&key) {
+ return false
+ }
+
+ if !self.is_focused.get() {
+ return false
+ }
+
+ if mods.ctrl || mods.alt {
+ if repeat {
+ return false
+ }
+ self.handle_shortcut(key, &mods).await;
+ return true
+ }
+
+ let actions = {
+ let mut repeater = self.key_repeat.lock().unwrap();
+ repeater.key_down(PressedKey::Char(key), repeat)
+ };
+ //debug!(target: "ui::chatedit", "Key {:?} has {} actions", key, actions);
+ for _ in 0..actions {
+ self.insert_char(key).await;
+ }
+ true
+ }
+
+ async fn handle_key_down(&self, 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::chatedit", "Key {:?} has {} actions", key, actions);
+ }*/
+ for _ in 0..actions {
+ self.handle_key(&key, &mods).await;
+ }
+ true
+ }
+
+ async fn handle_mouse_btn_down(&self, btn: MouseButton, mouse_pos: Point) -> bool {
+ if !self.is_active.get() {
+ return false
+ }
+
+ if btn != MouseButton::Left {
+ return false
+ }
+
+ let rect = self.rect.get();
+
+ // clicking inside box will:
+ // 1. make it active
+ // 2. begin selection
+ if !rect.contains(mouse_pos) {
+ if self.is_focused.get() {
+ debug!(target: "ui::chatedit", "EditBox unfocused");
+ self.is_focused.set(false);
+ self.select.lock().unwrap().clear();
+
+ self.redraw().await;
+ }
+ return false
+ }
+
+ if self.is_focused.get() {
+ debug!(target: "ui::chatedit", "EditBox clicked");
+ } else {
+ debug!(target: "ui::chatedit", "EditBox focused");
+ self.is_focused.set(true);
+ }
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+
+ {
+ let mut editable = self.editable.lock().unwrap();
+ let rendered = editable.render();
+ let x = mouse_pos.x - rect.x + self.scroll.get();
+
+ let cpos = rendered.x_to_pos(x, font_size, window_scale, baseline);
+ let cidx = rendered.pos_to_idx(cpos);
+ editable.set_cursor_idx(cidx);
+
+ // begin selection
+ let mut select = self.select.lock().unwrap();
+ select.clear();
+ select.push(Selection::new(cpos, cpos));
+
+ self.mouse_btn_held.store(true, Ordering::Relaxed);
+ }
+
+ self.pause_blinking();
+ self.redraw().await;
+ true
+ }
+
+ async fn handle_mouse_btn_up(&self, btn: MouseButton, mouse_pos: Point) -> bool {
+ if !self.is_active.get() {
+ return false
+ }
+
+ // releasing mouse button will end selection
+ self.mouse_btn_held.store(false, Ordering::Relaxed);
+ false
+ }
+
+ async fn handle_mouse_move(&self, mouse_pos: Point) -> bool {
+ if !self.is_active.get() {
+ return false
+ }
+
+ let rect = self.rect.get();
+ self.is_mouse_hover.store(rect.contains(mouse_pos), Ordering::Relaxed);
+
+ if !self.mouse_btn_held.load(Ordering::Relaxed) {
+ return false;
+ }
+
+ // if active and selection_active, then use x to modify the selection.
+ // also implement scrolling when cursor is to the left or right
+ // just scroll to the end
+ // also set cursor_pos too
+
+ let font_size = self.font_size.get();
+ let window_scale = self.window_scale.get();
+ let baseline = self.baseline.get();
+
+ {
+ let mut editable = self.editable.lock().unwrap();
+ let rendered = editable.render();
+ let x = mouse_pos.x - rect.x + self.scroll.get();
+
+ let cpos = rendered.x_to_pos(x, font_size, window_scale, baseline);
+ let cidx = rendered.pos_to_idx(cpos);
+ editable.set_cursor_idx(cidx);
+
+ // begin selection
+ let mut select = self.select.lock().unwrap();
+ select.last_mut().unwrap().end = cpos;
+ }
+
+ self.pause_blinking();
+ //self.apply_cursor_scrolling();
+ self.redraw().await;
+ true
+ }
+
+ async fn handle_mouse_wheel(&self, wheel_pos: Point) -> bool {
+ //debug!(target: "ui::chatedit", "rect={rect:?}, wheel_pos={wheel_pos:?}");
+ if !self.is_mouse_hover.load(Ordering::Relaxed) {
+ return false
+ }
+
+ let mut scroll = self.scroll.get() + wheel_pos.y * self.scroll_speed.get();
+ scroll = scroll.clamp(0., self.max_cursor_scroll());
+ debug!(target: "ui::chatedit", "handle_mouse_wheel({wheel_pos:?}) [scroll={scroll}]");
+ self.scroll.set(scroll);
+ self.redraw().await;
+
+ true
+ }
+
+ async fn handle_touch(&self, phase: TouchPhase, id: u64, touch_pos: Point) -> bool {
+ if !self.is_active.get() {
+ return false
+ }
+
+ // Ignore multi-touch
+ if id != 0 {
+ return false
+ }
+
+ match phase {
+ TouchPhase::Started => self.handle_touch_start(touch_pos).await,
+ TouchPhase::Moved => self.handle_touch_move(touch_pos).await,
+ TouchPhase::Ended => self.handle_touch_end(touch_pos).await,
+ TouchPhase::Cancelled => false,
+ }
+ }
+
+ async fn handle_compose_text(&self, suggest_text: &str, is_commit: bool) -> bool {
+ debug!(target: "ui::chatedit", "handle_compose_text({suggest_text}, {is_commit})");
+
+ if !self.is_active.get() {
+ return false
+ }
+
+ {
+ let mut editable = self.editable.lock().unwrap();
+ editable.compose(suggest_text, is_commit);
+ }
+
+ //self.apply_cursor_scrolling();
+ self.clamp_scroll();
+ self.redraw().await;
+
+ true
+ }
+ async fn handle_set_compose_region(&self, start: usize, end: usize) -> bool {
+ debug!(target: "ui::chatedit", "handle_set_compose_region({start}, {end})");
+
+ if !self.is_active.get() {
+ return false
+ }
+
+ {
+ let mut editable = self.editable.lock().unwrap();
+ editable.set_compose_region(start, end);
+ }
+
+ self.redraw().await;
+
+ true
+ }
+}
diff --git a/bin/darkwallet/src/ui/editbox/editable.rs b/bin/darkwallet/src/ui/editbox/editable.rs
index fc75457cd..25940f78a 100644
--- a/bin/darkwallet/src/ui/editbox/editable.rs
+++ b/bin/darkwallet/src/ui/editbox/editable.rs
@@ -25,8 +25,8 @@ use crate::{
util::{enumerate_ref, is_whitespace},
};
-pub(super) type TextPos = usize;
-pub(super) type TextIdx = usize;
+pub type TextPos = usize;
+pub type TextIdx = usize;
/// Android composing text from autosuggest.
/// We need this because IMEs can arbitrary set a composing region after
@@ -88,7 +88,7 @@ impl ComposingText {
}
}
-pub(super) struct RenderedEditable {
+pub struct RenderedEditable {
pub glyphs: Vec,
pub under_start: TextPos,
pub under_end: TextPos,
@@ -187,7 +187,7 @@ impl RenderedEditable {
/// to first render and move in terms of glyphs due to kerning. For example the chars "ae"
/// may be rendered as a single glyph in some fonts. Same for emojis represented by multiple
/// chars which are often not even a single byte.
-pub(super) struct Editable {
+pub struct Editable {
text_shaper: TextShaperPtr,
composer: ComposingText,
@@ -370,7 +370,7 @@ fn glyphs_to_string(glyphs: &Vec) -> String {
}
#[derive(Debug, Clone)]
-pub(super) struct Selection {
+pub struct Selection {
pub start: TextPos,
pub end: TextPos,
}
diff --git a/bin/darkwallet/src/ui/editbox/mod.rs b/bin/darkwallet/src/ui/editbox/mod.rs
index 07efae98e..6b6e5d710 100644
--- a/bin/darkwallet/src/ui/editbox/mod.rs
+++ b/bin/darkwallet/src/ui/editbox/mod.rs
@@ -51,15 +51,18 @@ use crate::{
use super::{DrawUpdate, OnModify, UIObject};
-mod editable;
+pub mod editable;
use editable::{Editable, Selection, TextIdx, TextPos};
+pub mod repeat;
+use repeat::{PressedKey, PressedKeysSmoothRepeat};
+
// EOL whitespace is given a nudge since it has a width of 0 after text shaping
const CURSOR_EOL_WS_NUDGE: f32 = 0.8;
// EOL chars are more aesthetic when given a smallish nudge
const CURSOR_EOL_NUDGE: f32 = 0.2;
-fn eol_nudge(font_size: f32, glyphs: &Vec) -> f32 {
+pub fn eol_nudge(font_size: f32, glyphs: &Vec) -> f32 {
if is_whitespace(&glyphs.last().unwrap().substr) {
(font_size * CURSOR_EOL_WS_NUDGE).round()
} else {
@@ -67,82 +70,6 @@ fn eol_nudge(font_size: f32, glyphs: &Vec) -> f32 {
}
}
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
-enum PressedKey {
- Char(char),
- Key(KeyCode),
-}
-
-/// On key press (repeat=false), we immediately process the event.
-/// Then there's a delay (repeat=true) and then for every step time
-/// while key press events are being sent, we allow an event.
-/// This ensures smooth typing in the editbox.
-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: PressedKey, repeat: bool) -> u32 {
- //debug!(target: "PressedKeysSmoothRepeat", "key_down({:?}, {})", key, repeat);
-
- if !repeat {
- self.pressed_keys.remove(&key);
- return 1;
- }
-
- // Insert key if not exists
- if !self.pressed_keys.contains_key(&key) {
- //debug!(target: "PressedKeysSmoothRepeat", "insert key {:?}", key);
- self.pressed_keys.insert(key.clone(), 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: &PressedKey) {
- //debug!(target: "PressedKeysSmoothRepeat", "key_up({:?})", key);
- assert!(self.pressed_keys.contains_key(key));
- self.pressed_keys.remove(key).expect("key was pressed");
- }
- */
-}
-
-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();
- //debug!(target: "RepeatingKeyTimer", "update() elapsed={}, actions={}",
- // elapsed, self.actions);
- 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 TouchStartInfo {
pos: Point,
@@ -1645,11 +1572,11 @@ impl UIObject for EditBox {
/// Filter these char events from being handled since we handle them
/// using the key_up/key_down events.
/// Avoids duplicate processing of keyboard input events.
-static DISALLOWED_CHARS: &'static [char] = &['\r', '\u{8}', '\u{7f}', '\t', '\n'];
+pub static DISALLOWED_CHARS: &'static [char] = &['\r', '\u{8}', '\u{7f}', '\t', '\n'];
/// These keycodes are handled via normal key_up/key_down events.
/// Anything in this list must be disallowed char events.
-static ALLOWED_KEYCODES: &'static [KeyCode] = &[
+pub static ALLOWED_KEYCODES: &'static [KeyCode] = &[
KeyCode::Left,
KeyCode::Right,
KeyCode::Up,
@@ -1672,16 +1599,3 @@ static ALLOWED_KEYCODES: &'static [KeyCode] = &[
KeyCode::Home,
KeyCode::End,
];
-
-/*
-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/editbox/repeat.rs b/bin/darkwallet/src/ui/editbox/repeat.rs
new file mode 100644
index 000000000..51352250e
--- /dev/null
+++ b/bin/darkwallet/src/ui/editbox/repeat.rs
@@ -0,0 +1,96 @@
+/* This file is part of DarkFi (https://dark.fi)
+ *
+ * Copyright (C) 2020-2024 Dyne.org foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ */
+
+use miniquad::KeyCode;
+use std::{collections::HashMap, time::Instant};
+
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
+pub enum PressedKey {
+ Char(char),
+ Key(KeyCode),
+}
+
+/// On key press (repeat=false), we immediately process the event.
+/// Then there's a delay (repeat=true) and then for every step time
+/// while key press events are being sent, we allow an event.
+/// This ensures smooth typing in the editbox.
+pub 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 {
+ pub fn new(start_delay: u32, step_time: u32) -> Self {
+ Self { pressed_keys: HashMap::new(), start_delay, step_time }
+ }
+
+ pub fn key_down(&mut self, key: PressedKey, repeat: bool) -> u32 {
+ //debug!(target: "PressedKeysSmoothRepeat", "key_down({:?}, {})", key, repeat);
+
+ if !repeat {
+ self.pressed_keys.remove(&key);
+ return 1;
+ }
+
+ // Insert key if not exists
+ if !self.pressed_keys.contains_key(&key) {
+ //debug!(target: "PressedKeysSmoothRepeat", "insert key {:?}", key);
+ self.pressed_keys.insert(key.clone(), 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: &PressedKey) {
+ //debug!(target: "PressedKeysSmoothRepeat", "key_up({:?})", key);
+ assert!(self.pressed_keys.contains_key(key));
+ self.pressed_keys.remove(key).expect("key was pressed");
+ }
+ */
+}
+
+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();
+ //debug!(target: "RepeatingKeyTimer", "update() elapsed={}, actions={}",
+ // elapsed, self.actions);
+ 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
+ }
+}
diff --git a/bin/darkwallet/src/ui/mod.rs b/bin/darkwallet/src/ui/mod.rs
index a0b0462fc..ee6a0383c 100644
--- a/bin/darkwallet/src/ui/mod.rs
+++ b/bin/darkwallet/src/ui/mod.rs
@@ -34,11 +34,13 @@ mod button;
pub use button::{Button, ButtonPtr};
pub mod chatview;
pub use chatview::{ChatView, ChatViewPtr};
+mod chatedit;
+pub use chatedit::{ChatEdit, ChatEditPtr};
mod editbox;
pub use editbox::{EditBox, EditBoxPtr};
mod image;
pub use image::{Image, ImagePtr};
-pub mod vector_art;
+mod vector_art;
pub use vector_art::{
shape::{ShapeVertex, VectorShape},
VectorArt, VectorArtPtr,
@@ -167,6 +169,7 @@ pub fn get_ui_object_ptr(node: &SceneNode3) -> Arc {
Pimpl::VectorArt(obj) => obj.clone(),
Pimpl::Text(obj) => obj.clone(),
Pimpl::EditBox(obj) => obj.clone(),
+ Pimpl::ChatEdit(obj) => obj.clone(),
Pimpl::ChatView(obj) => obj.clone(),
Pimpl::Image(obj) => obj.clone(),
Pimpl::Button(obj) => obj.clone(),
@@ -179,6 +182,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::ChatEdit(obj) => obj.as_ref(),
Pimpl::ChatView(obj) => obj.as_ref(),
Pimpl::Image(obj) => obj.as_ref(),
Pimpl::Button(obj) => obj.as_ref(),