@effindomv2/fui-rs 0.1.16 → 0.1.18

package/src/controls/tests.rs

@@ -213,7 +213,9 @@ fn press_enter(node_ref: &crate::node::NodeRef) {
 }
 
 fn key_event(event_type: KeyEventType, key: &str, modifiers: u32) -> bool {
-    event::__fui_on_key_event(event_type as u32, key.as_ptr(), key.len() as u32, modifiers)
+    unsafe {
+        event::__fui_on_key_event(event_type as u32, key.as_ptr(), key.len() as u32, modifiers)
+    }
 }
 
 fn blur(node_ref: &crate::node::NodeRef) {
@@ -1407,7 +1409,7 @@ fn retained_dropdown_keeps_theme_subscription_after_wrapper_drop() {
     let mut theme = current_theme();
     theme.colors.surface = 0x135724FF;
     theme.colors.border = 0x246813FF;
-    theme.colors.text_primary = 0xABCDEFff;
+    theme.colors.text_primary = 0xABCDEFFF;
     use_custom_theme(theme.clone());
     let calls = ffi::test::take_calls();
 
@@ -4212,7 +4214,9 @@ fn text_input_text_replaced_event_updates_value_and_emits_changed() {
         })
         .expect("expected text input editor node id to be applied");
 
-    event::__fui_on_text_replaced(editor_handle, 0, 0, b"hello".as_ptr(), 5);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 0, 0, b"hello".as_ptr(), 5);
+    }
 
     assert_eq!(input.value(), "hello");
     assert_eq!(&*last_text.borrow(), "hello");
@@ -4474,7 +4478,9 @@ fn text_input_text_replacement_clamps_selection_bytes_from_char_positions() {
         })
         .expect("expected text input editor node id to be applied");
 
-    event::__fui_on_text_replaced(editor_handle, 1, 5, std::ptr::null(), 0);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 1, 5, std::ptr::null(), 0);
+    }
 
     assert_eq!(input.value(), "ab");
     assert_eq!(input.selection_start(), 0);
@@ -4660,16 +4666,22 @@ fn text_area_readonly_disabled_placeholder_and_line_height_follow_text_input_cor
             if *handle == editor_handle && (*line_height - 26.0).abs() < f32::EPSILON
     )));
 
-    event::__fui_on_text_replaced(editor_handle, 0, 0, b"Hello\nworld".as_ptr(), 11);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 0, 0, b"Hello\nworld".as_ptr(), 11);
+    }
     assert_eq!(input.value(), "Hello\nworld");
 
-    event::__fui_on_text_changed(editor_handle, b"alpha\nbeta".as_ptr(), 10);
+    unsafe {
+        event::__fui_on_text_changed(editor_handle, b"alpha\nbeta".as_ptr(), 10);
+    }
     assert_eq!(input.value(), "alpha\nbeta");
     event::__fui_on_selection_changed(editor_handle, 6, 10);
     assert_eq!(input.selection_start(), 6);
     assert_eq!(input.selection_end(), 10);
 
-    event::__fui_on_text_replaced(editor_handle, 0, 11, std::ptr::null(), 0);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 0, 11, std::ptr::null(), 0);
+    }
     assert_eq!(input.value(), "");
     Application::unmount();
 }

package/src/debug.rs

@@ -2,6 +2,7 @@ use crate::event::{self, PointerType};
 use crate::ffi::{self, KeyEventType, PointerEventType};
 use crate::node::NodeHandle;
 
+#[allow(clippy::too_many_arguments)]
 pub fn pointer_event(
     event_type: PointerEventType,
     handle: NodeHandle,
@@ -42,7 +43,7 @@ pub fn key_event(event_type: KeyEventType, key: &str, modifiers: u32) -> bool {
     event::dispatch_key_event(event_type, key.to_string(), modifiers)
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_debug_pointer_event(
     event_type: u32,
     handle: u64,
@@ -74,8 +75,10 @@ pub extern "C" fn __fui_debug_pointer_event(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_debug_key_event(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `key_ptr` must be null for an empty key or point to `key_len` readable bytes.
+pub unsafe extern "C" fn __fui_debug_key_event(
     event_type: u32,
     key_ptr: *const u8,
     key_len: u32,
@@ -97,12 +100,12 @@ pub extern "C" fn __fui_debug_key_event(
     );
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), 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]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_debug_scroll(
     handle: u64,
     offset_x: f32,

package/src/drag_drop.rs

@@ -399,9 +399,7 @@ fn finish_session(
     notify_target_leave: bool,
 ) {
     let target = with_state(|state| {
-        let Some(active) = state.active_session.as_ref() else {
-            return None;
-        };
+        let active = state.active_session.as_ref()?;
         if !Rc::ptr_eq(&active.inner, &session.inner) {
             return None;
         }

package/src/drawing.rs

@@ -1,8 +1,10 @@
+#![allow(clippy::too_many_arguments)]
+
 use crate::ffi;
 use crate::image_sampling::ImageSampling;
 use crate::logger::error;
 use crate::node::Node;
-use crate::text::TextLayout;
+use crate::text::{DynamicTextLayout, TextLayout};
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -78,6 +80,12 @@ pub struct Path {
     resource: Rc<PathResource>,
 }
 
+impl Default for Path {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Path {
     pub fn new() -> Self {
         let id = unsafe { ffi::fui_path_create() };
@@ -317,6 +325,18 @@ impl DrawContext {
         self.draw_text_node(&node, x, y);
     }
 
+    pub fn draw_dynamic_text_layout(&self, layout: &DynamicTextLayout, x: f32, y: f32) {
+        if !layout.is_ready() {
+            error(
+                "DynamicTextLayout",
+                "DrawContext.draw_dynamic_text_layout() called before the DynamicTextLayout was ready; register on_ready and draw after the callback.",
+            );
+            return;
+        }
+        let node = layout.draw_node();
+        self.draw_text_node(&node, x, y);
+    }
+
     pub fn draw_image(&self, texture_id: u32, x: f32, y: f32, w: f32, h: f32) {
         self.draw_image_sampling(texture_id, x, y, w, h, ImageSampling::linear());
     }
@@ -355,8 +375,13 @@ impl DrawContext {
 #[cfg(test)]
 mod tests {
     use super::{DrawContext, Paint, Path};
+    use crate::assets;
     use crate::ffi::{self, Call};
+    use crate::frame_scheduler;
     use crate::image_sampling::ImageSampling;
+    use crate::text::DynamicTextLayout;
+    use crate::typography::FontStack;
+    use crate::Unit;
 
     #[test]
     fn path_and_draw_context_emit_batched_host_calls() {
@@ -386,4 +411,33 @@ mod tests {
             Call::CanvasDrawBatch { canvas_ptr: 77, words } if !words.is_empty()
         )));
     }
+
+    #[test]
+    fn draw_dynamic_text_layout_emits_text_command_without_exposing_draw_node() {
+        ffi::test::reset();
+        frame_scheduler::reset_commit_state();
+        assets::test_reset();
+
+        let layout = DynamicTextLayout::fixed_charset("0123456789");
+        layout
+            .font_stack(FontStack::from_id(1), 14.0)
+            .width(72.0, Unit::Pixel)
+            .height(20.0, Unit::Pixel)
+            .set_text("42");
+        layout.on_ready(|_| {});
+        frame_scheduler::fire_loaded_callbacks();
+        assert!(layout.is_ready());
+        ffi::test::take_calls();
+
+        let ctx = DrawContext::new(88);
+        ctx.draw_dynamic_text_layout(&layout, 5.0, 7.0);
+        ctx.flush();
+
+        let calls = ffi::test::take_calls();
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::CanvasDrawBatch { canvas_ptr: 88, words }
+                if words.first() == Some(&super::OP_DRAW_TEXT_NODE)
+        )));
+    }
 }

package/src/event.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::too_many_arguments)]
+
 use crate::context_menu_manager;
 use crate::drag_drop;
 use crate::external_drop;
@@ -1331,27 +1333,27 @@ pub(crate) fn dispatch_external_drop_event(
     })
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_key_buffer() -> *const u8 {
     std::ptr::addr_of_mut!(KEY_BUFFER).cast::<u8>()
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_key_buffer_size() -> u32 {
     256
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_text_buffer() -> *const u8 {
     std::ptr::addr_of_mut!(TEXT_BUFFER).cast::<u8>()
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_text_buffer_size() -> u32 {
     (16 * 1024) as u32
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_pointer_event_with_metadata(
     event_type: u32,
     handle: u64,
@@ -1391,7 +1393,7 @@ pub extern "C" fn __fui_on_pointer_event_with_metadata(
     )
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_wheel_event(
     handle: u64,
     x: f32,
@@ -1412,8 +1414,10 @@ pub extern "C" fn __fui_on_wheel_event(
     )
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_key_event(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `key_ptr` must be null for an empty key or point to `key_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_key_event(
     event_type: u32,
     key_ptr: *const u8,
     key_len: u32,
@@ -1435,13 +1439,15 @@ pub extern "C" fn __fui_on_key_event(
     )
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_focus_changed(handle: u64, focused: bool) {
     dispatch_focus_changed(NodeHandle::from_raw(handle), focused);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_text_changed(handle: u64, text_ptr: *const u8, text_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `text_ptr` must be null for empty text or point to `text_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_text_changed(handle: u64, text_ptr: *const u8, text_len: u32) {
     let text = if text_ptr.is_null() || text_len == 0 {
         String::new()
     } else {
@@ -1451,8 +1457,10 @@ pub extern "C" fn __fui_on_text_changed(handle: u64, text_ptr: *const u8, text_l
     dispatch_text_changed(NodeHandle::from_raw(handle), text);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_text_replaced(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `text_ptr` must be null for empty replacement text or point to `text_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_text_replaced(
     handle: u64,
     start: u32,
     end: u32,
@@ -1468,13 +1476,15 @@ pub extern "C" fn __fui_on_text_replaced(
     dispatch_text_replaced(NodeHandle::from_raw(handle), start, end, text);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_selection_changed(handle: u64, start: u32, end: u32) {
     dispatch_selection_changed(NodeHandle::from_raw(handle), start, end);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_cross_selection_changed(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `text_ptr` must be null for empty text or point to `text_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_cross_selection_changed(
     handle: u64,
     text_ptr: *const u8,
     text_len: u32,
@@ -1488,17 +1498,17 @@ pub extern "C" fn __fui_on_cross_selection_changed(
     dispatch_cross_selection_changed(NodeHandle::from_raw(handle), text);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_resolve_gesture_owner(handle: u64) -> u64 {
     resolve_gesture_owner(NodeHandle::from_raw(handle)).raw()
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_get_gesture_intent(handle: u64) -> u32 {
     get_gesture_intent(NodeHandle::from_raw(handle)) as u32
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_gesture_event(
     handle: u64,
     phase: u32,
@@ -1523,27 +1533,27 @@ pub extern "C" fn __fui_on_gesture_event(
     )
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_resolve_long_press_owner(handle: u64) -> u64 {
     resolve_long_press_owner(NodeHandle::from_raw(handle)).raw()
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_get_long_press_minimum_duration_ms(handle: u64) -> i32 {
     get_long_press_minimum_duration_ms(NodeHandle::from_raw(handle))
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_get_long_press_movement_tolerance(handle: u64) -> f32 {
     get_long_press_movement_tolerance(NodeHandle::from_raw(handle))
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_long_press_continues_pointer_events(handle: u64) -> bool {
     registered_node(handle).is_some_and(|node| node.has_drag_source())
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_long_press_event(
     handle: u64,
     scene_x: f32,
@@ -1564,8 +1574,10 @@ pub extern "C" fn __fui_on_long_press_event(
     )
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_external_drag_event(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_external_drag_event(
     event_type: u32,
     handle: u64,
     x: f32,
@@ -1595,7 +1607,7 @@ pub extern "C" fn __fui_on_external_drag_event(
     effect as u32
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn fui_dispatch_custom_draw(handle: u64, canvas_ptr: usize) {
     if let Some(node) = resolve_node(NodeHandle::from_raw(handle)) {
         node.handle_custom_draw(canvas_ptr);

package/src/fetch.rs

@@ -337,8 +337,10 @@ pub fn reset_fetch_runtime() {
     });
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_fetch_complete(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_fetch_complete(
     request_id: u32,
     ok: bool,
     status: i32,
@@ -361,8 +363,14 @@ pub extern "C" fn __fui_on_fetch_complete(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_fetch_error(request_id: u32, payload_ptr: *const u8, payload_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_fetch_error(
+    request_id: u32,
+    payload_ptr: *const u8,
+    payload_len: u32,
+) {
     let message = if payload_ptr.is_null() || payload_len == 0 {
         "Fetch request failed.".to_string()
     } else {
@@ -413,7 +421,9 @@ mod tests {
             }
             bytes
         };
-        super::__fui_on_fetch_complete(1, true, 200, payload.as_ptr(), payload.len() as u32);
+        unsafe {
+            super::__fui_on_fetch_complete(1, true, 200, payload.as_ptr(), payload.len() as u32);
+        }
         assert_eq!(&*result.borrow(), "OK");
         drop(request);
     }
@@ -464,7 +474,9 @@ mod tests {
             }
             bytes
         };
-        super::__fui_on_fetch_complete(1, true, 200, payload.as_ptr(), payload.len() as u32);
+        unsafe {
+            super::__fui_on_fetch_complete(1, true, 200, payload.as_ptr(), payload.len() as u32);
+        }
         assert_eq!(&*result.borrow(), "");
         drop(request);
     }
@@ -493,7 +505,9 @@ mod tests {
                 result_clone.replace(event.message);
             })
             .start();
-        super::__fui_on_fetch_error(1, std::ptr::null(), 0);
+        unsafe {
+            super::__fui_on_fetch_error(1, std::ptr::null(), 0);
+        }
         assert_eq!(&*result.borrow(), "Fetch request failed.");
         drop(request);
     }

package/src/ffi.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::too_many_arguments, clippy::type_complexity)]
+
 pub use crate::generated::ffi::*;
 
 #[cfg(all(not(target_arch = "wasm32"), not(feature = "native-runtime")))]
@@ -3433,7 +3435,7 @@ pub unsafe fn fui_canvas_create_offscreen(width: u32, height: u32) -> u32 {
 #[cfg(all(not(target_arch = "wasm32"), not(feature = "native-runtime")))]
 pub unsafe fn fui_canvas_get_offscreen_ptr(offscreen_id: u32) -> usize {
     push_call(Call::CanvasGetOffscreenPtr { offscreen_id });
-    (0x1000 + offscreen_id as usize) as usize
+    0x1000 + offscreen_id as usize
 }
 
 #[cfg(all(not(target_arch = "wasm32"), not(feature = "native-runtime")))]