@effindomv2/fui-rs 0.1.3

package/src/generated/framework_host_services.rs

@@ -0,0 +1,74 @@
+// Generated by hostgen from ./scripts/framework-host-services.ts#frameworkHostServices.
+// Do not edit by hand.
+
+#![allow(dead_code)]
+#![allow(non_snake_case)]
+#[cfg(any(target_family = "wasm", feature = "native-runtime"))]
+#[cfg_attr(target_family = "wasm", link(wasm_import_module = "fui_host"))]
+unsafe extern "C" {
+    #[link_name = "fui_get_accent_color"]
+    fn __host_fui_get_accent_color() -> u32;
+    #[link_name = "fui_get_platform_family"]
+    fn __host_fui_get_platform_family() -> u32;
+    #[link_name = "fui_is_coarse_pointer"]
+    fn __host_fui_is_coarse_pointer() -> bool;
+    #[link_name = "fui_is_dark_mode"]
+    fn __host_fui_is_dark_mode() -> bool;
+    #[link_name = "fui_now_ms"]
+    fn __host_fui_now_ms() -> f64;
+}
+
+pub fn fui_get_accent_color() -> u32 {
+  #[cfg(any(target_family = "wasm", feature = "native-runtime"))]
+  {
+    unsafe { __host_fui_get_accent_color() }
+  }
+  #[cfg(all(not(target_family = "wasm"), not(feature = "native-runtime")))]
+  {
+    unsafe { crate::ffi::fui_get_accent_color() }
+  }
+}
+
+pub fn fui_get_platform_family() -> u32 {
+  #[cfg(any(target_family = "wasm", feature = "native-runtime"))]
+  {
+    unsafe { __host_fui_get_platform_family() }
+  }
+  #[cfg(all(not(target_family = "wasm"), not(feature = "native-runtime")))]
+  {
+    unsafe { crate::ffi::fui_get_platform_family() }
+  }
+}
+
+pub fn fui_is_coarse_pointer() -> bool {
+  #[cfg(any(target_family = "wasm", feature = "native-runtime"))]
+  {
+    unsafe { __host_fui_is_coarse_pointer() }
+  }
+  #[cfg(all(not(target_family = "wasm"), not(feature = "native-runtime")))]
+  {
+    unsafe { crate::ffi::fui_is_coarse_pointer() }
+  }
+}
+
+pub fn fui_is_dark_mode() -> bool {
+  #[cfg(any(target_family = "wasm", feature = "native-runtime"))]
+  {
+    unsafe { __host_fui_is_dark_mode() }
+  }
+  #[cfg(all(not(target_family = "wasm"), not(feature = "native-runtime")))]
+  {
+    unsafe { crate::ffi::fui_is_dark_mode() }
+  }
+}
+
+pub fn fui_now_ms() -> f64 {
+  #[cfg(any(target_family = "wasm", feature = "native-runtime"))]
+  {
+    unsafe { __host_fui_now_ms() }
+  }
+  #[cfg(all(not(target_family = "wasm"), not(feature = "native-runtime")))]
+  {
+    crate::ffi::test::host_now_ms()
+  }
+}

package/src/generated/mod.rs

@@ -0,0 +1,2 @@
+pub mod ffi;
+pub mod framework_host_services;

package/src/host_services.rs

@@ -0,0 +1,162 @@
+use crate::event;
+
+pub fn host_service_result_buffer_ptr() -> *mut u8 {
+    event::__fui_text_buffer() as *mut u8
+}
+
+pub fn host_service_result_buffer_size() -> u32 {
+    event::__fui_text_buffer_size()
+}
+
+fn assert_result_byte_length(result_len: u32, import_name: &str) {
+    let capacity = host_service_result_buffer_size();
+    if result_len > capacity {
+        panic!(
+            "Host service {} returned {} bytes but the shared result buffer only holds {}.",
+            import_name, result_len, capacity
+        );
+    }
+}
+
+pub fn decode_host_service_string_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> String {
+    assert_result_byte_length(result_len, import_name);
+    if result_len == 0 {
+        return String::new();
+    }
+    let bytes = unsafe { std::slice::from_raw_parts(result_ptr as *const u8, result_len as usize) };
+    String::from_utf8_lossy(bytes).into_owned()
+}
+
+pub fn decode_host_service_bytes_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> Vec<u8> {
+    assert_result_byte_length(result_len, import_name);
+    if result_len == 0 {
+        return Vec::new();
+    }
+    unsafe { std::slice::from_raw_parts(result_ptr as *const u8, result_len as usize) }.to_vec()
+}
+
+pub fn decode_host_service_i32_array_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> Vec<i32> {
+    assert_result_byte_length(result_len, import_name);
+    assert_eq!(
+        result_len & 3,
+        0,
+        "Host service {} returned misaligned i32 array byte length.",
+        import_name
+    );
+    if result_len == 0 {
+        return Vec::new();
+    }
+    unsafe {
+        std::slice::from_raw_parts(result_ptr as *const i32, (result_len >> 2) as usize).to_vec()
+    }
+}
+
+pub fn decode_host_service_u32_array_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> Vec<u32> {
+    assert_result_byte_length(result_len, import_name);
+    assert_eq!(
+        result_len & 3,
+        0,
+        "Host service {} returned misaligned u32 array byte length.",
+        import_name
+    );
+    if result_len == 0 {
+        return Vec::new();
+    }
+    unsafe {
+        std::slice::from_raw_parts(result_ptr as *const u32, (result_len >> 2) as usize).to_vec()
+    }
+}
+
+pub fn decode_host_service_i64_array_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> Vec<i64> {
+    assert_result_byte_length(result_len, import_name);
+    assert_eq!(
+        result_len & 7,
+        0,
+        "Host service {} returned misaligned i64 array byte length.",
+        import_name
+    );
+    if result_len == 0 {
+        return Vec::new();
+    }
+    unsafe {
+        std::slice::from_raw_parts(result_ptr as *const i64, (result_len >> 3) as usize).to_vec()
+    }
+}
+
+pub fn decode_host_service_u64_array_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> Vec<u64> {
+    assert_result_byte_length(result_len, import_name);
+    assert_eq!(
+        result_len & 7,
+        0,
+        "Host service {} returned misaligned u64 array byte length.",
+        import_name
+    );
+    if result_len == 0 {
+        return Vec::new();
+    }
+    unsafe {
+        std::slice::from_raw_parts(result_ptr as *const u64, (result_len >> 3) as usize).to_vec()
+    }
+}
+
+pub fn decode_host_service_f64_array_result(
+    result_ptr: *mut u8,
+    result_len: u32,
+    import_name: &str,
+) -> Vec<f64> {
+    assert_result_byte_length(result_len, import_name);
+    assert_eq!(
+        result_len & 7,
+        0,
+        "Host service {} returned misaligned f64 array byte length.",
+        import_name
+    );
+    if result_len == 0 {
+        return Vec::new();
+    }
+    unsafe {
+        std::slice::from_raw_parts(result_ptr as *const f64, (result_len >> 3) as usize).to_vec()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decodes_string_result_from_shared_text_buffer() {
+        let ptr = host_service_result_buffer_ptr();
+        let bytes = b"demo-host";
+        unsafe {
+            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, bytes.len());
+        }
+        assert_eq!(
+            decode_host_service_string_result(ptr, bytes.len() as u32, "demo_service"),
+            "demo-host"
+        );
+    }
+}

package/src/image_sampling.rs

@@ -0,0 +1,78 @@
+use crate::ffi::ImageSamplingKind;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ImageSamplingMode {
+    Linear,
+    Nearest,
+    LinearMipmapNearest,
+    LinearMipmapLinear,
+    CubicMitchell,
+    CubicCatmullRom,
+    Anisotropic,
+}
+
+impl ImageSamplingMode {
+    pub(crate) fn ffi_kind(self) -> ImageSamplingKind {
+        match self {
+            Self::Linear => ImageSamplingKind::Linear,
+            Self::Nearest => ImageSamplingKind::Nearest,
+            Self::LinearMipmapNearest => ImageSamplingKind::LinearMipmapNearest,
+            Self::LinearMipmapLinear => ImageSamplingKind::LinearMipmapLinear,
+            Self::CubicMitchell => ImageSamplingKind::CubicMitchell,
+            Self::CubicCatmullRom => ImageSamplingKind::CubicCatmullRom,
+            Self::Anisotropic => ImageSamplingKind::Anisotropic,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ImageSampling {
+    kind: ImageSamplingMode,
+    max_aniso: u32,
+}
+
+impl ImageSampling {
+    pub fn linear() -> Self {
+        Self::new(ImageSamplingMode::Linear, 0)
+    }
+
+    pub fn nearest() -> Self {
+        Self::new(ImageSamplingMode::Nearest, 0)
+    }
+
+    pub fn linear_mipmap_nearest() -> Self {
+        Self::new(ImageSamplingMode::LinearMipmapNearest, 0)
+    }
+
+    pub fn linear_mipmap_linear() -> Self {
+        Self::new(ImageSamplingMode::LinearMipmapLinear, 0)
+    }
+
+    pub fn cubic_mitchell() -> Self {
+        Self::new(ImageSamplingMode::CubicMitchell, 0)
+    }
+
+    pub fn cubic_catmull_rom() -> Self {
+        Self::new(ImageSamplingMode::CubicCatmullRom, 0)
+    }
+
+    pub fn anisotropic(max_aniso: u32) -> Self {
+        Self::new(ImageSamplingMode::Anisotropic, max_aniso)
+    }
+
+    pub fn new(kind: ImageSamplingMode, max_aniso: u32) -> Self {
+        Self { kind, max_aniso }
+    }
+
+    pub fn kind(self) -> ImageSamplingMode {
+        self.kind
+    }
+
+    pub(crate) fn ffi_kind(self) -> ImageSamplingKind {
+        self.kind.ffi_kind()
+    }
+
+    pub fn max_aniso(self) -> u32 {
+        self.max_aniso
+    }
+}

package/src/keyboard_scroll.rs

@@ -0,0 +1,137 @@
+use crate::event;
+
+const KEYBOARD_SCROLL_LINE_STEP: f32 = 40.0;
+const KEYBOARD_SCROLL_PAGE_OVERLAP: f32 = 40.0;
+const KEYBOARD_SCROLL_TOLERANCE: f32 = 0.5;
+
+fn is_keyboard_scroll_key(key: &str) -> bool {
+    matches!(
+        key,
+        "ArrowLeft"
+            | "ArrowRight"
+            | "ArrowUp"
+            | "ArrowDown"
+            | "PageUp"
+            | "PageDown"
+            | "Home"
+            | "End"
+    )
+}
+
+fn is_horizontal_keyboard_scroll_key(key: &str) -> bool {
+    matches!(key, "ArrowLeft" | "ArrowRight")
+}
+
+fn is_vertical_keyboard_scroll_key(key: &str) -> bool {
+    matches!(
+        key,
+        "ArrowUp" | "ArrowDown" | "PageUp" | "PageDown" | "Home" | "End"
+    )
+}
+
+fn page_step(viewport_height: f32) -> f32 {
+    if viewport_height <= 0.0 {
+        return 0.0;
+    }
+    if viewport_height > KEYBOARD_SCROLL_PAGE_OVERLAP {
+        return viewport_height - KEYBOARD_SCROLL_PAGE_OVERLAP;
+    }
+    viewport_height * 0.875
+}
+
+fn clamp(value: f32, min_value: f32, max_value: f32) -> f32 {
+    if value < min_value {
+        min_value
+    } else if value > max_value {
+        max_value
+    } else {
+        value
+    }
+}
+
+fn try_scroll_viewport(handle: crate::node::NodeHandle, key: &str) -> bool {
+    let Some(node) = event::resolve_node(handle) else {
+        return false;
+    };
+    let Some(state) = node.scroll_routing_state() else {
+        return false;
+    };
+    if is_horizontal_keyboard_scroll_key(key) {
+        if !state.enabled_x {
+            return false;
+        }
+        let max_offset_x = (state.content_width - state.viewport_width).max(0.0);
+        if max_offset_x <= KEYBOARD_SCROLL_TOLERANCE {
+            return false;
+        }
+        let current_offset_x = clamp(state.offset_x, 0.0, max_offset_x);
+        let mut next_offset_x = match key {
+            "ArrowLeft" => current_offset_x - KEYBOARD_SCROLL_LINE_STEP,
+            "ArrowRight" => current_offset_x + KEYBOARD_SCROLL_LINE_STEP,
+            _ => return false,
+        };
+        next_offset_x = clamp(next_offset_x, 0.0, max_offset_x);
+        if (next_offset_x - current_offset_x).abs() <= KEYBOARD_SCROLL_TOLERANCE {
+            return false;
+        }
+        crate::bindings::ui::set_scroll_offset(handle.raw(), next_offset_x, state.offset_y);
+        node.set_scroll_routing_offsets(next_offset_x, state.offset_y);
+        return true;
+    }
+
+    if !is_vertical_keyboard_scroll_key(key) || !state.enabled_y {
+        return false;
+    }
+    let max_offset_y = (state.content_height - state.viewport_height).max(0.0);
+    if max_offset_y <= KEYBOARD_SCROLL_TOLERANCE {
+        return false;
+    }
+    let current_offset_y = clamp(state.offset_y, 0.0, max_offset_y);
+    let mut next_offset_y = match key {
+        "ArrowUp" => current_offset_y - KEYBOARD_SCROLL_LINE_STEP,
+        "ArrowDown" => current_offset_y + KEYBOARD_SCROLL_LINE_STEP,
+        "PageUp" => current_offset_y - page_step(state.viewport_height),
+        "PageDown" => current_offset_y + page_step(state.viewport_height),
+        "Home" => 0.0,
+        "End" => max_offset_y,
+        _ => return false,
+    };
+    next_offset_y = clamp(next_offset_y, 0.0, max_offset_y);
+    if (next_offset_y - current_offset_y).abs() <= KEYBOARD_SCROLL_TOLERANCE {
+        return false;
+    }
+    crate::bindings::ui::set_scroll_offset(handle.raw(), state.offset_x, next_offset_y);
+    node.set_scroll_routing_offsets(state.offset_x, next_offset_y);
+    true
+}
+
+pub(crate) fn handle_keyboard_scroll_fallback(key: &str, modifiers: u32) -> bool {
+    if modifiers != 0 || !is_keyboard_scroll_key(key) {
+        return false;
+    }
+
+    if let Some(focused_node) = event::focused_node() {
+        let mut current = Some(focused_node);
+        while let Some(node) = current {
+            if node.is_scroll_view_for_routing() && try_scroll_viewport(node.handle(), key) {
+                return true;
+            }
+            current = node.parent();
+        }
+    }
+
+    if let Some(selected_candidate) =
+        crate::keyboard_scroll_tracker::get_keyboard_scroll_selected_candidate()
+    {
+        if try_scroll_viewport(selected_candidate, key) {
+            return true;
+        }
+    }
+
+    for candidate in crate::keyboard_scroll_tracker::get_keyboard_scroll_fallback_candidates() {
+        if try_scroll_viewport(candidate, key) {
+            return true;
+        }
+    }
+    false
+}