@effindomv2/fui-rs 0.1.3

package/src/controls/text_area.rs

@@ -0,0 +1,207 @@
+use super::internal::text_input_core::TextInputCore;
+use super::internal::text_input_presenter::TextInputTemplate;
+use super::TextInputColors;
+use crate::event::{FocusChangedEventArgs, SelectionChangedEventArgs, TextChangedEventArgs};
+use crate::node::{FlexBox, HasFlexBoxRoot, Node, NodeRef, ScrollBarVisibility};
+use crate::FontFamily;
+use std::any::Any;
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub struct TextArea {
+    core: Rc<TextInputCore>,
+}
+
+impl Default for TextArea {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TextArea {
+    pub fn new() -> Self {
+        let core = Rc::new(TextInputCore::multiline());
+        core.finish_init(Rc::downgrade(&core));
+        Self { core }
+    }
+
+    pub fn text(&self, value: impl Into<String>) -> &Self {
+        self.core.text(value);
+        self
+    }
+
+    pub fn value(&self) -> String {
+        self.core.value()
+    }
+
+    pub fn selection_start(&self) -> u32 {
+        self.core.selection_start()
+    }
+
+    pub fn selection_end(&self) -> u32 {
+        self.core.selection_end()
+    }
+
+    pub fn selection_start_byte_offset(&self) -> u32 {
+        self.core.selection_start_byte_offset()
+    }
+
+    pub fn selection_end_byte_offset(&self) -> u32 {
+        self.core.selection_end_byte_offset()
+    }
+
+    pub fn placeholder(&self, value: impl Into<String>) -> &Self {
+        self.core.placeholder(value);
+        self
+    }
+
+    pub fn max_chars(&self, limit: i32) -> &Self {
+        self.core.max_chars(limit);
+        self
+    }
+
+    pub fn read_only(&self, flag: bool) -> &Self {
+        self.core.read_only(flag);
+        self
+    }
+
+    pub fn accepts_tab(&self, flag: bool) -> &Self {
+        self.core.accepts_tab(flag);
+        self
+    }
+
+    pub fn selection_range(&self, start: u32, end: u32) -> &Self {
+        self.core.selection_range(start, end);
+        self
+    }
+
+    pub fn caret(&self, position: u32) -> &Self {
+        self.core.caret(position);
+        self
+    }
+
+    pub fn caret_to_end(&self) -> &Self {
+        self.core.caret_to_end();
+        self
+    }
+
+    pub fn colors(&self, colors: Option<TextInputColors>) -> &Self {
+        self.core.colors(colors);
+        self
+    }
+
+    pub fn template(&self, template: Option<Rc<dyn TextInputTemplate>>) -> &Self {
+        self.core.template(template);
+        self
+    }
+
+    pub fn enabled(&self, enabled: bool) -> &Self {
+        self.core.enabled(enabled);
+        self
+    }
+
+    pub fn focusable(&self, enabled: bool, tab_index: i32) -> &Self {
+        self.core.focusable(enabled, tab_index);
+        self
+    }
+
+    pub fn node_id(&self, id: impl Into<String>) -> &Self {
+        self.core.node_id(id);
+        self
+    }
+
+    pub fn line_height(&self, value: f32) -> &Self {
+        self.core.line_height(value);
+        self
+    }
+
+    pub fn font_family(&self, family: FontFamily) -> &Self {
+        self.core.font_family(family);
+        self
+    }
+
+    pub fn font_size(&self, size: f32) -> &Self {
+        self.core.font_size(size);
+        self
+    }
+
+    pub fn wrapping(&self, flag: bool) -> &Self {
+        self.core.wrapping(flag);
+        self
+    }
+
+    pub fn vertical_scrollbar_visibility(&self, mode: ScrollBarVisibility) -> &Self {
+        self.core.vertical_scrollbar_visibility(mode);
+        self
+    }
+
+    pub fn horizontal_scrollbar_visibility(&self, mode: ScrollBarVisibility) -> &Self {
+        self.core.horizontal_scrollbar_visibility(mode);
+        self
+    }
+
+    pub fn on_changed(&self, handler: impl Fn(TextChangedEventArgs) + 'static) -> &Self {
+        self.core.on_changed(handler);
+        self
+    }
+
+    pub fn on_text_changed(&self, handler: impl Fn(TextChangedEventArgs) + 'static) -> &Self {
+        self.core.on_text_changed(handler);
+        self
+    }
+
+    pub fn on_selection_changed(
+        &self,
+        handler: impl Fn(SelectionChangedEventArgs) + 'static,
+    ) -> &Self {
+        self.core.on_selection_changed(handler);
+        self
+    }
+
+    pub fn on_focus_changed(&self, handler: impl Fn(FocusChangedEventArgs) + 'static) -> &Self {
+        self.core.on_focus_changed(handler);
+        self
+    }
+
+    pub fn focus_now(&self) -> &Self {
+        self.core.focus_now();
+        self
+    }
+
+    pub fn scroll_offset_x(&self) -> f32 {
+        self.core.scroll_offset_x()
+    }
+
+    pub fn scroll_offset_y(&self) -> f32 {
+        self.core.scroll_offset_y()
+    }
+
+    pub fn scroll_to(&self, x: f32, y: f32) -> &Self {
+        self.core.scroll_to(x, y);
+        self
+    }
+}
+
+impl HasFlexBoxRoot for TextArea {
+    fn flex_box_root(&self) -> &FlexBox {
+        self.core.flex_box_root()
+    }
+}
+
+impl Node for TextArea {
+    fn retained_node_ref(&self) -> NodeRef {
+        let core = self.core.clone();
+        self.core
+            .flex_box_root()
+            .retained_node_ref()
+            .with_build_callback(move || core.build_control())
+    }
+
+    fn retained_owner_attachment(&self) -> Option<Rc<dyn Any>> {
+        Some(self.core.clone())
+    }
+
+    fn build_self(&self) {
+        self.core.build_control();
+    }
+}

package/src/controls/text_input.rs

@@ -0,0 +1,192 @@
+use super::internal::text_input_core::TextInputCore;
+use super::internal::text_input_presenter::TextInputTemplate;
+use super::TextInputColors;
+use crate::event::{FocusChangedEventArgs, SelectionChangedEventArgs, TextChangedEventArgs};
+use crate::node::{FlexBox, HasFlexBoxRoot, Node, NodeRef, TextCore};
+use crate::FontFamily;
+use std::any::Any;
+use std::rc::Rc;
+
+#[derive(Clone, Default)]
+pub struct TextInput {
+    core: Rc<TextInputCore>,
+}
+
+impl TextInput {
+    pub fn new() -> Self {
+        let core = Rc::new(TextInputCore::new());
+        core.finish_init(Rc::downgrade(&core));
+        Self { core }
+    }
+
+    pub fn text(&self, value: impl Into<String>) -> &Self {
+        self.core.text(value);
+        self
+    }
+
+    pub fn value(&self) -> String {
+        self.core.value()
+    }
+
+    pub fn selection_start(&self) -> u32 {
+        self.core.selection_start()
+    }
+
+    pub fn selection_end(&self) -> u32 {
+        self.core.selection_end()
+    }
+
+    pub fn selection_start_byte_offset(&self) -> u32 {
+        self.core.selection_start_byte_offset()
+    }
+
+    pub fn selection_end_byte_offset(&self) -> u32 {
+        self.core.selection_end_byte_offset()
+    }
+
+    pub fn placeholder(&self, value: impl Into<String>) -> &Self {
+        self.core.placeholder(value);
+        self
+    }
+
+    pub fn max_chars(&self, limit: i32) -> &Self {
+        self.core.max_chars(limit);
+        self
+    }
+
+    pub fn read_only(&self, flag: bool) -> &Self {
+        self.core.read_only(flag);
+        self
+    }
+
+    pub fn accepts_tab(&self, flag: bool) -> &Self {
+        self.core.accepts_tab(flag);
+        self
+    }
+
+    pub fn password(&self, flag: bool) -> &Self {
+        self.core.password(flag);
+        self
+    }
+
+    pub fn host_autofill(&self, hint: impl AsRef<str>) -> &Self {
+        self.core.host_autofill(Some(hint.as_ref()));
+        self
+    }
+
+    pub fn clear_host_autofill(&self) -> &Self {
+        self.core.host_autofill(None);
+        self
+    }
+
+    pub fn selection_range(&self, start: u32, end: u32) -> &Self {
+        self.core.selection_range(start, end);
+        self
+    }
+
+    pub fn caret(&self, position: u32) -> &Self {
+        self.core.caret(position);
+        self
+    }
+
+    pub fn caret_to_end(&self) -> &Self {
+        self.core.caret_to_end();
+        self
+    }
+
+    pub fn colors(&self, colors: Option<TextInputColors>) -> &Self {
+        self.core.colors(colors);
+        self
+    }
+
+    pub fn template(&self, template: Option<Rc<dyn TextInputTemplate>>) -> &Self {
+        self.core.template(template);
+        self
+    }
+
+    pub fn enabled(&self, enabled: bool) -> &Self {
+        self.core.enabled(enabled);
+        self
+    }
+
+    pub fn focusable(&self, enabled: bool, tab_index: i32) -> &Self {
+        self.core.focusable(enabled, tab_index);
+        self
+    }
+
+    pub fn node_id(&self, id: impl Into<String>) -> &Self {
+        self.core.node_id(id);
+        self
+    }
+
+    pub fn line_height(&self, value: f32) -> &Self {
+        self.core.line_height(value);
+        self
+    }
+
+    pub fn font_family(&self, family: FontFamily) -> &Self {
+        self.core.font_family(family);
+        self
+    }
+
+    pub fn font_size(&self, size: f32) -> &Self {
+        self.core.font_size(size);
+        self
+    }
+
+    pub fn on_changed(&self, handler: impl Fn(TextChangedEventArgs) + 'static) -> &Self {
+        self.core.on_changed(handler);
+        self
+    }
+
+    pub fn on_text_changed(&self, handler: impl Fn(TextChangedEventArgs) + 'static) -> &Self {
+        self.core.on_text_changed(handler);
+        self
+    }
+
+    pub fn on_selection_changed(
+        &self,
+        handler: impl Fn(SelectionChangedEventArgs) + 'static,
+    ) -> &Self {
+        self.core.on_selection_changed(handler);
+        self
+    }
+
+    pub fn on_focus_changed(&self, handler: impl Fn(FocusChangedEventArgs) + 'static) -> &Self {
+        self.core.on_focus_changed(handler);
+        self
+    }
+
+    pub fn focus_now(&self) -> &Self {
+        self.core.focus_now();
+        self
+    }
+
+    pub(crate) fn editor_node(&self) -> TextCore {
+        self.core.editor_node()
+    }
+}
+
+impl HasFlexBoxRoot for TextInput {
+    fn flex_box_root(&self) -> &FlexBox {
+        self.core.flex_box_root()
+    }
+}
+
+impl Node for TextInput {
+    fn retained_node_ref(&self) -> NodeRef {
+        let core = self.core.clone();
+        self.core
+            .flex_box_root()
+            .retained_node_ref()
+            .with_build_callback(move || core.build_control())
+    }
+
+    fn retained_owner_attachment(&self) -> Option<Rc<dyn Any>> {
+        Some(self.core.clone())
+    }
+
+    fn build_self(&self) {
+        self.core.build_control();
+    }
+}

package/src/debug.rs

@@ -0,0 +1,146 @@
+use crate::event::{self, PointerType};
+use crate::ffi::{self, KeyEventType, PointerEventType};
+use crate::node::NodeHandle;
+
+pub fn pointer_event(
+    event_type: PointerEventType,
+    handle: NodeHandle,
+    x: f32,
+    y: f32,
+    modifiers: u32,
+    pointer_id: i32,
+    pointer_type: PointerType,
+    button: i32,
+    buttons: u32,
+    pressure: f32,
+    width: f32,
+    height: f32,
+    click_count: i32,
+) -> bool {
+    event::dispatch_pointer_event(
+        handle,
+        event_type,
+        x,
+        y,
+        modifiers,
+        pointer_id,
+        pointer_type,
+        button,
+        buttons,
+        pressure,
+        width,
+        height,
+        click_count,
+    )
+}
+
+pub fn focus_changed(handle: NodeHandle, focused: bool) {
+    event::dispatch_focus_changed(handle, focused);
+}
+
+pub fn key_event(event_type: KeyEventType, key: &str, modifiers: u32) -> bool {
+    event::dispatch_key_event(event_type, key.to_string(), modifiers)
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_debug_pointer_event(
+    event_type: u32,
+    handle: u64,
+    x: f32,
+    y: f32,
+    modifiers: u32,
+) {
+    event::dispatch_pointer_event(
+        NodeHandle::from_raw(handle),
+        match event_type {
+            1 => PointerEventType::Down,
+            2 => PointerEventType::Up,
+            3 => PointerEventType::Move,
+            4 => PointerEventType::Enter,
+            5 => PointerEventType::Leave,
+            _ => PointerEventType::Cancel,
+        },
+        x,
+        y,
+        modifiers,
+        -1,
+        PointerType::Mouse,
+        0,
+        0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_debug_key_event(
+    event_type: u32,
+    key_ptr: *const u8,
+    key_len: u32,
+    modifiers: u32,
+) {
+    let key = if key_ptr.is_null() || key_len == 0 {
+        String::new()
+    } else {
+        let bytes = unsafe { std::slice::from_raw_parts(key_ptr, key_len as usize) };
+        String::from_utf8_lossy(bytes).into_owned()
+    };
+    event::dispatch_key_event(
+        match event_type {
+            2 => KeyEventType::Up,
+            _ => KeyEventType::Down,
+        },
+        key,
+        modifiers,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_debug_focus_changed(handle: u64, focused: bool) {
+    event::dispatch_focus_changed(NodeHandle::from_raw(handle), focused);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_debug_scroll(
+    handle: u64,
+    offset_x: f32,
+    offset_y: f32,
+    content_width: f32,
+    content_height: f32,
+    viewport_width: f32,
+    viewport_height: f32,
+) {
+    event::dispatch_scroll(
+        NodeHandle::from_raw(handle),
+        offset_x,
+        offset_y,
+        content_width,
+        content_height,
+        viewport_width,
+        viewport_height,
+    );
+}
+
+pub fn debug_tree_words() -> Vec<u32> {
+    let mut len = 0u32;
+    let ptr = unsafe { ffi::ui_get_debug_tree_buffer(&mut len as *mut u32) };
+    if ptr.is_null() || len == 0 {
+        return Vec::new();
+    }
+    unsafe { std::slice::from_raw_parts(ptr, len as usize) }.to_vec()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::debug_tree_words;
+    use crate::ffi;
+
+    #[test]
+    fn reads_debug_tree_words_from_host() {
+        ffi::test::reset();
+        ffi::test::set_debug_tree_words(&[1, 2, 3, 4]);
+        assert_eq!(debug_tree_words(), vec![1, 2, 3, 4]);
+    }
+}