@effindomv2/fui-rs 0.1.22 → 0.1.24

package/src/controls/internal/text_input_core.rs

@@ -12,11 +12,12 @@ use crate::ffi::{
     CursorStyle, KeyEventType, KeyModifier, PositionType, SemanticRole, TextVerticalAlign, Unit,
 };
 use crate::node::{
-    flex_box, FlexBox, FlexBoxSurface, HasFlexBoxRoot, Node, NodeHandle, ScrollBarVisibility,
-    ScrollBox, TextCore,
+    flex_box, ChildContainerSurface, FlexBox, HasFlexBoxRoot, LayoutSurface, Node, NodeHandle,
+    ScrollBarVisibility, ScrollBox, TextNode,
 };
 use crate::persisted::{persisted_value_adapter, PersistedStringCodec};
 use crate::signal::SubscriptionGuard;
+use crate::text_indices::{scalar_count, scalar_to_byte};
 use crate::theme::{current_theme, subscribe};
 use crate::{focus_adorner, focus_visibility};
 use std::cell::{Cell, RefCell};
@@ -77,39 +78,6 @@ fn create_presenter(
     create_default_text_input_presenter()
 }
 
-fn char_count(text: &str) -> u32 {
-    text.chars().count() as u32
-}
-
-fn char_to_byte(text: &str, index: u32) -> u32 {
-    let target = min(index, char_count(text)) as usize;
-    if target == 0 {
-        return 0;
-    }
-    for (position, (byte, _)) in text.char_indices().enumerate() {
-        if position == target {
-            return byte as u32;
-        }
-    }
-    text.len() as u32
-}
-
-fn byte_to_char(text: &str, byte_index: u32) -> u32 {
-    let target = min(byte_index as usize, text.len());
-    let mut count = 0;
-    for (byte, _) in text.char_indices() {
-        if byte >= target {
-            break;
-        }
-        count += 1;
-    }
-    if target == text.len() {
-        text.chars().count() as u32
-    } else {
-        count
-    }
-}
-
 fn is_enabled(root: &FlexBox) -> bool {
     root.retained_node_ref().is_enabled_for_routing()
 }
@@ -118,9 +86,9 @@ pub struct TextInputCore {
     self_weak: RefCell<Weak<TextInputCore>>,
     profile: TextInputProfile,
     root: FlexBox,
-    editor_text: TextCore,
+    editor_text: TextNode,
     editor_scroll_box: Option<ScrollBox>,
-    placeholder_text: TextCore,
+    placeholder_text: TextNode,
     placeholder_host: FlexBox,
     placeholder_attached: Cell<bool>,
     presenter: RefCell<Rc<dyn TextInputPresenter>>,
@@ -167,14 +135,14 @@ impl TextInputCore {
             .reflect_semantic_disabled_from_enabled()
             .selection_area_barrier(true);
 
-        let editor_text = TextCore::new("");
+        let editor_text = TextNode::new_core("");
         editor_text
             .semantic_role(SemanticRole::Textbox)
             .reflect_semantic_disabled_from_enabled()
             .focusable(true, 0)
             .selectable(true)
             .editable(true);
-        let placeholder_text = TextCore::new("");
+        let placeholder_text = TextNode::new_core("");
         let placeholder_host = flex_box();
         placeholder_host
             .position_type(PositionType::Absolute)
@@ -333,16 +301,16 @@ impl TextInputCore {
 
     pub fn selection_range(&self, start: u32, end: u32) -> &Self {
         let text = self.text_value.borrow();
-        let start = min(start, char_count(&text));
-        let end = min(end, char_count(&text));
-        let start_bytes = char_to_byte(&text, start);
-        let end_bytes = char_to_byte(&text, end);
+        let start = min(start, scalar_count(&text));
+        let end = min(end, scalar_count(&text));
+        let start_bytes = scalar_to_byte(&text, start);
+        let end_bytes = scalar_to_byte(&text, end);
         drop(text);
         self.selection_start_chars.set(start);
         self.selection_end_chars.set(end);
         self.selection_start_bytes.set(start_bytes);
         self.selection_end_bytes.set(end_bytes);
-        self.editor_text.selection_range(start_bytes, end_bytes);
+        self.editor_text.selection_range(start, end);
         self
     }
 
@@ -351,7 +319,7 @@ impl TextInputCore {
     }
 
     pub fn caret_to_end(&self) -> &Self {
-        let end = char_count(&self.text_value.borrow());
+        let end = scalar_count(&self.text_value.borrow());
         self.selection_range(end, end)
     }
 
@@ -387,6 +355,11 @@ impl TextInputCore {
         self
     }
 
+    pub fn semantic_label(&self, label: impl Into<String>) -> &Self {
+        self.editor_text.semantic_label(label);
+        self
+    }
+
     pub fn line_height(&self, value: f32) -> &Self {
         self.editor_text.line_height(value);
         self.placeholder_text.line_height(value);
@@ -463,16 +436,15 @@ impl TextInputCore {
         self
     }
 
-    pub fn on_focus_changed(&self, handler: impl Fn(FocusChangedEventArgs) + 'static) -> &Self {
-        *self.focus_changed_callback.borrow_mut() = Some(Rc::new(handler));
-        self
+    pub(crate) fn set_focus_changed_callback(&self, handler: Rc<dyn Fn(FocusChangedEventArgs)>) {
+        *self.focus_changed_callback.borrow_mut() = Some(handler);
     }
 
     pub fn focus_now(&self) -> &Self {
         self.focus_editor();
         self.editor_text.selection_range(
-            self.selection_start_bytes.get(),
-            self.selection_end_bytes.get(),
+            self.selection_start_chars.get(),
+            self.selection_end_chars.get(),
         );
         self
     }
@@ -762,7 +734,7 @@ impl TextInputCore {
     }
 
     fn handle_editor_text_changed(&self) {
-        let value = self.editor_text.text_value();
+        let value = self.editor_text.content();
         if *self.text_value.borrow() == value {
             return;
         }
@@ -779,13 +751,11 @@ impl TextInputCore {
     }
 
     fn handle_editor_selection_changed(&self, start: u32, end: u32) {
-        self.selection_start_bytes.set(start);
-        self.selection_end_bytes.set(end);
         let text = self.text_value.borrow();
-        let start_chars = byte_to_char(&text, start);
-        let end_chars = byte_to_char(&text, end);
-        let start_bytes = char_to_byte(&text, start_chars);
-        let end_bytes = char_to_byte(&text, end_chars);
+        let start_chars = min(start, scalar_count(&text));
+        let end_chars = min(end, scalar_count(&text));
+        let start_bytes = scalar_to_byte(&text, start_chars);
+        let end_bytes = scalar_to_byte(&text, end_chars);
         drop(text);
         self.selection_start_bytes.set(start_bytes);
         self.selection_end_bytes.set(end_bytes);
@@ -845,15 +815,15 @@ impl TextInputCore {
             .selection_start_chars
             .get()
             .max(self.selection_end_chars.get());
-        let current_len = char_count(&text);
-        let inserted_len = char_count(inserted);
+        let current_len = scalar_count(&text);
+        let inserted_len = scalar_count(inserted);
         let replaced_len = end - start;
         if current_len - replaced_len + inserted_len > self.max_chars_value.get() as u32 {
             return;
         }
 
-        let start_byte = char_to_byte(&text, start) as usize;
-        let end_byte = char_to_byte(&text, end) as usize;
+        let start_byte = scalar_to_byte(&text, start) as usize;
+        let end_byte = scalar_to_byte(&text, end) as usize;
         let mut value =
             String::with_capacity(text.len() - (end_byte - start_byte) + inserted.len());
         value.push_str(&text[..start_byte]);
@@ -864,7 +834,7 @@ impl TextInputCore {
         *self.text_value.borrow_mut() = value.clone();
         let handle = self.editor_text.handle();
         if handle != NodeHandle::INVALID {
-            let caret_byte = char_to_byte(&value, caret);
+            let caret_byte = scalar_to_byte(&value, caret);
             ui::replace_text_range(
                 handle.raw(),
                 start_byte as u32,
@@ -997,11 +967,11 @@ impl TextInputCore {
 
     fn clamp_selection_to_text(&self) {
         let text = self.text_value.borrow();
-        let char_len = char_count(&text);
+        let char_len = scalar_count(&text);
         let start_chars = min(self.selection_start_chars.get(), char_len);
         let end_chars = min(self.selection_end_chars.get(), char_len);
-        let start_bytes = char_to_byte(&text, start_chars);
-        let end_bytes = char_to_byte(&text, end_chars);
+        let start_bytes = scalar_to_byte(&text, start_chars);
+        let end_bytes = scalar_to_byte(&text, end_chars);
         drop(text);
         self.selection_start_chars.set(start_chars);
         self.selection_end_chars.set(end_chars);
@@ -1079,12 +1049,12 @@ impl TextInputCore {
         self.root.build();
         self.sync_browser_input_metadata();
         self.editor_text.selection_range(
-            self.selection_start_bytes.get(),
-            self.selection_end_bytes.get(),
+            self.selection_start_chars.get(),
+            self.selection_end_chars.get(),
         );
     }
 
-    pub(crate) fn editor_node(&self) -> TextCore {
+    pub(crate) fn editor_node(&self) -> TextNode {
         self.editor_text.clone()
     }
 }

package/src/controls/internal/text_input_presenter.rs

@@ -1,6 +1,6 @@
 use crate::controls::TextInputColors;
 use crate::ffi::{CursorStyle, Unit};
-use crate::node::{Border, Corners, EdgeInsets, FlexBox, PresenterHostStyle, TextCore};
+use crate::node::{Border, Corners, EdgeInsets, FlexBox, PresenterHostStyle, TextNode};
 use crate::theme::Theme;
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -13,7 +13,7 @@ pub struct TextInputVisualState {
 }
 
 pub trait TextInputPresenter {
-    fn bind(&self, editor_host: TextCore, placeholder_host: FlexBox);
+    fn bind(&self, editor_host: TextNode, placeholder_host: FlexBox);
     fn present(
         &self,
         theme: Theme,
@@ -28,7 +28,7 @@ pub trait TextInputTemplate {
 
 #[derive(Clone, Default)]
 pub struct DefaultTextInputPresenter {
-    editor_host: RefCell<Option<TextCore>>,
+    editor_host: RefCell<Option<TextNode>>,
     placeholder_host: RefCell<Option<FlexBox>>,
 }
 
@@ -39,7 +39,7 @@ impl DefaultTextInputPresenter {
 }
 
 impl TextInputPresenter for DefaultTextInputPresenter {
-    fn bind(&self, editor_host: TextCore, placeholder_host: FlexBox) {
+    fn bind(&self, editor_host: TextNode, placeholder_host: FlexBox) {
         *self.editor_host.borrow_mut() = Some(editor_host);
         *self.placeholder_host.borrow_mut() = Some(placeholder_host);
     }

package/src/controls/mod.rs

@@ -5,8 +5,7 @@ use crate::ffi::{
     SemanticCheckedState, SemanticRole, Unit,
 };
 use crate::node::{
-    flex_box, row, Child, FlexBox, HasFlexBoxRoot, Node, NodeRef, TextNode, ThemeBindable,
-    WeakNodeRef,
+    flex_box, row, FlexBox, HasFlexBoxRoot, Node, NodeRef, TextNode, ThemeBindable, WeakNodeRef,
 };
 use crate::theme::{current_theme, subscribe};
 use std::cell::{Cell, RefCell};
@@ -19,8 +18,14 @@ use radio_group::WeakRadioGroupEventTarget;
 pub(crate) use shared::*;
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct ClickEventArgs {
-    pub click_count: i32,
+pub struct ClickEventArgs;
+
+/// Semantic click activation for controls whose primary action can be invoked
+/// by pointer, keyboard, or another supported activation source.
+///
+/// Use [`Node::on_pointer_click`] when raw routed pointer data is required.
+pub trait Clickable: Sized {
+    fn on_click(&self, handler: impl Fn(ClickEventArgs) + 'static) -> &Self;
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -129,6 +134,7 @@ pub mod templating;
 #[cfg(test)]
 mod tests;
 pub mod text_area;
+mod text_editor_surface;
 pub mod text_input;
 
 pub use anti_selection_area::AntiSelectionArea;
@@ -185,6 +191,7 @@ pub use templating::{
     DEFAULT_SLIDER_TEMPLATE, DEFAULT_SWITCH_INDICATOR_TEMPLATE, DEFAULT_TEXT_INPUT_TEMPLATE,
 };
 pub use text_area::TextArea;
+pub use text_editor_surface::TextEditorSurface;
 pub use text_input::TextInput;
 
 pub fn button(label: impl Into<String>) -> Button {

package/src/controls/popup.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::ffi::{FlexDirection, PositionType, Unit};
-use crate::node::{portal, Child};
+use crate::node::portal;
 use crate::popup_presenter::{PopupPlacement, PopupPresenter};
 use std::cell::Cell;
 
@@ -37,7 +37,7 @@ impl Popup {
         presenter
             .overlay_node()
             .interactive(true)
-            .on_click(move |_event| {
+            .on_pointer_click(move |_event| {
                 if dismiss_flag.get() {
                     presenter_target.hide();
                 }
@@ -55,6 +55,8 @@ impl Popup {
         self.presenter.is_open()
     }
 
+    /// Returns the presented content panel. Inherited `child`/`children` calls
+    /// are routed here rather than into the portal's overlay root.
     pub fn surface(&self) -> FlexBox {
         self.surface_node.clone()
     }
@@ -91,24 +93,6 @@ impl Popup {
         self
     }
 
-    pub fn child<T: Node>(&self, node: &T) -> &Self {
-        self.surface_node.child(node);
-        self
-    }
-
-    pub fn children<I, C>(&self, nodes: I) -> &Self
-    where
-        I: IntoIterator<Item = C>,
-        C: Into<Child>,
-    {
-        for node in nodes {
-            self.surface_node
-                .retained_node_ref()
-                .append_child_ref(&node.into().node_ref);
-        }
-        self
-    }
-
     fn sync_appearance(&self) {
         let appearance = self.appearance_value.borrow().clone().unwrap_or_default();
         let panel = appearance.panel.unwrap_or_default();
@@ -172,4 +156,35 @@ impl crate::node::HasFlexBoxRoot for Popup {
     fn flex_box_root(&self) -> &FlexBox {
         &self.root
     }
+
+    fn append_flex_box_surface_child(&self, child: NodeRef) {
+        self.surface_node
+            .retained_node_ref()
+            .append_child_ref(&child);
+    }
+}
+
+impl crate::node::ThemeBindable for Popup {
+    fn theme_binding_node(&self) -> NodeRef {
+        self.root.retained_node_ref()
+    }
+
+    fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
+        let root = self.root.downgrade();
+        let surface_node = self.surface_node.downgrade();
+        let presenter = self.presenter.downgrade();
+        let dismiss_on_backdrop_click = Rc::downgrade(&self.dismiss_on_backdrop_click);
+        // Appearance state does not own the portal root. Keep it alive with the
+        // retained theme binding so a dropped wrapper remains reconstructible.
+        let appearance_value = self.appearance_value.clone();
+        Box::new(move || {
+            Some(Self {
+                root: root.upgrade()?,
+                surface_node: surface_node.upgrade()?,
+                presenter: presenter.upgrade()?,
+                dismiss_on_backdrop_click: dismiss_on_backdrop_click.upgrade()?,
+                appearance_value: appearance_value.clone(),
+            })
+        })
+    }
 }

package/src/controls/radio_button.rs

@@ -221,6 +221,13 @@ impl RadioButton {
     }
 }
 
+impl Clickable for RadioButton {
+    fn on_click(&self, handler: impl Fn(ClickEventArgs) + 'static) -> &Self {
+        self.base.on_click(handler);
+        self
+    }
+}
+
 impl LabeledControlTextStyle for RadioButton {
     fn set_label_font_family(&self, family: crate::FontFamily) {
         self.base.font_family(family);

package/src/controls/radio_group.rs

@@ -286,4 +286,21 @@ impl crate::node::HasFlexBoxRoot for RadioGroup {
     }
 }
 
+impl crate::node::ThemeBindable for RadioGroup {
+    fn theme_binding_node(&self) -> NodeRef {
+        self.root.retained_node_ref()
+    }
+
+    fn weak_theme_target(&self) -> Box<dyn Fn() -> Option<Self>> {
+        let root = self.root.downgrade();
+        let event_target = Rc::downgrade(&self.event_target);
+        Box::new(move || {
+            Some(Self {
+                root: root.upgrade()?,
+                event_target: event_target.upgrade()?,
+            })
+        })
+    }
+}
+
 pub(crate) type WeakRadioGroupEventTarget = Weak<RadioGroupEventTarget>;

package/src/controls/selection_area.rs

@@ -27,24 +27,6 @@ impl SelectionArea {
         }
     }
 
-    pub fn child<T: Node>(&self, node: &T) -> &Self {
-        self.root.child(node);
-        self
-    }
-
-    pub fn children<I, C>(&self, nodes: I) -> &Self
-    where
-        I: IntoIterator<Item = C>,
-        C: Into<Child>,
-    {
-        for node in nodes {
-            self.root
-                .retained_node_ref()
-                .append_child_ref(&node.into().node_ref);
-        }
-        self
-    }
-
     pub fn selected_text(&self) -> String {
         self.selected_text_signal.borrow().get()
     }

package/src/controls/shared.rs

@@ -20,24 +20,9 @@ pub(crate) fn is_activation_key(event: &KeyEventArgs) -> bool {
     event.key == "Enter" || event.key == " " || event.key == "Space" || event.key == "Spacebar"
 }
 
-pub(crate) fn fire_click_callbacks(
-    click: &Rc<RefCell<Option<ClickCallback>>>,
-    double_click: &Rc<RefCell<Option<ClickCallback>>>,
-    triple_click: &Rc<RefCell<Option<ClickCallback>>>,
-    click_count: i32,
-) {
-    let args = ClickEventArgs { click_count };
+pub(crate) fn fire_click_callback(click: &Rc<RefCell<Option<ClickCallback>>>) {
     if let Some(callback) = click.borrow().clone() {
-        callback(args);
-    }
-    if click_count == 3 {
-        if let Some(callback) = triple_click.borrow().clone() {
-            callback(args);
-        }
-    } else if click_count == 2 {
-        if let Some(callback) = double_click.borrow().clone() {
-            callback(args);
-        }
+        callback(ClickEventArgs);
     }
 }
 

package/src/controls/switch.rs

@@ -212,6 +212,13 @@ impl Switch {
     }
 }
 
+impl Clickable for Switch {
+    fn on_click(&self, handler: impl Fn(ClickEventArgs) + 'static) -> &Self {
+        self.base.on_click(handler);
+        self
+    }
+}
+
 impl LabeledControlTextStyle for Switch {
     fn set_label_font_family(&self, family: crate::FontFamily) {
         self.base.font_family(family);