@effindomv2/fui-rs 0.1.3

package/src/focus_adorner.rs

@@ -0,0 +1,307 @@
+use crate::bindings::ui;
+use crate::ffi::{PositionType, Unit};
+use crate::node::{flex_box, portal, FlexBox, Node, NodeHandle};
+use crate::theme::current_theme;
+use std::cell::RefCell;
+
+const STANDARD_FOCUS_RING_WIDTH: f32 = 2.0;
+const STANDARD_FOCUS_RING_OUTSET: f32 = 2.0;
+const TRANSPARENT: u32 = 0x00000000;
+
+#[derive(Clone, Copy)]
+struct FocusAdornerStyle {
+    top_left_radius: f32,
+    top_right_radius: f32,
+    bottom_right_radius: f32,
+    bottom_left_radius: f32,
+}
+
+#[derive(Clone, Copy)]
+struct FocusAdornerRect {
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+}
+
+struct FocusAdornerState {
+    host_root: Option<FlexBox>,
+    ring_node: Option<FlexBox>,
+    active_owner: Option<NodeHandle>,
+    active_style: Option<FocusAdornerStyle>,
+    attached: bool,
+    last_host_x: f32,
+    last_host_y: f32,
+    last_host_width: f32,
+    last_host_height: f32,
+    last_ring_x: f32,
+    last_ring_y: f32,
+    last_ring_width: f32,
+    last_ring_height: f32,
+    last_color: u32,
+    last_top_left_radius: f32,
+    last_top_right_radius: f32,
+    last_bottom_right_radius: f32,
+    last_bottom_left_radius: f32,
+}
+
+impl FocusAdornerState {
+    fn new() -> Self {
+        Self {
+            host_root: None,
+            ring_node: None,
+            active_owner: None,
+            active_style: None,
+            attached: false,
+            last_host_x: f32::NAN,
+            last_host_y: f32::NAN,
+            last_host_width: f32::NAN,
+            last_host_height: f32::NAN,
+            last_ring_x: f32::NAN,
+            last_ring_y: f32::NAN,
+            last_ring_width: f32::NAN,
+            last_ring_height: f32::NAN,
+            last_color: 0,
+            last_top_left_radius: f32::NAN,
+            last_top_right_radius: f32::NAN,
+            last_bottom_right_radius: f32::NAN,
+            last_bottom_left_radius: f32::NAN,
+        }
+    }
+
+    fn reset_cached_geometry(&mut self) {
+        self.last_host_x = f32::NAN;
+        self.last_host_y = f32::NAN;
+        self.last_host_width = f32::NAN;
+        self.last_host_height = f32::NAN;
+        self.last_ring_x = f32::NAN;
+        self.last_ring_y = f32::NAN;
+        self.last_ring_width = f32::NAN;
+        self.last_ring_height = f32::NAN;
+        self.last_color = 0;
+        self.last_top_left_radius = f32::NAN;
+        self.last_top_right_radius = f32::NAN;
+        self.last_bottom_right_radius = f32::NAN;
+        self.last_bottom_left_radius = f32::NAN;
+    }
+}
+
+thread_local! {
+    static FOCUS_ADORNER_STATE: RefCell<FocusAdornerState> =
+        RefCell::new(FocusAdornerState::new());
+}
+
+pub(crate) fn create_default_host() -> FlexBox {
+    FOCUS_ADORNER_STATE.with(|slot| {
+        let mut state = slot.borrow_mut();
+        if let Some(existing_host) = state.host_root.as_ref() {
+            return existing_host.clone();
+        }
+        let ring_node = flex_box();
+        ring_node
+            .position_type(PositionType::Absolute)
+            .bg_color(TRANSPARENT)
+            .border(STANDARD_FOCUS_RING_WIDTH, TRANSPARENT);
+        let host_root = portal();
+        host_root
+            .position_type(PositionType::Absolute)
+            .position(0.0, 0.0)
+            .width(0.0, Unit::Pixel)
+            .height(0.0, Unit::Pixel)
+            .clip_to_bounds(false);
+        state.host_root = Some(host_root.clone());
+        state.ring_node = Some(ring_node);
+        host_root
+    })
+}
+
+pub(crate) fn clear() {
+    hide();
+    FOCUS_ADORNER_STATE.with(|slot| {
+        let mut state = slot.borrow_mut();
+        state.active_owner = None;
+        state.active_style = None;
+    });
+}
+
+pub(crate) fn show_standard<T: Node>(owner: &T, corner_radius: f32) {
+    show_standard_corners(
+        owner,
+        corner_radius,
+        corner_radius,
+        corner_radius,
+        corner_radius,
+    );
+}
+
+pub(crate) fn show_standard_corners<T: Node>(owner: &T, tl: f32, tr: f32, br: f32, bl: f32) {
+    FOCUS_ADORNER_STATE.with(|slot| {
+        let mut state = slot.borrow_mut();
+        state.active_owner = Some(owner.handle());
+        state.active_style = Some(FocusAdornerStyle {
+            top_left_radius: tl + STANDARD_FOCUS_RING_OUTSET,
+            top_right_radius: tr + STANDARD_FOCUS_RING_OUTSET,
+            bottom_right_radius: br + STANDARD_FOCUS_RING_OUTSET,
+            bottom_left_radius: bl + STANDARD_FOCUS_RING_OUTSET,
+        });
+    });
+    sync();
+}
+
+pub(crate) fn hide_owner<T: Node>(owner: &T) {
+    hide_owner_handle(owner.handle());
+}
+
+pub(crate) fn handle_owner_destroyed(owner: NodeHandle) {
+    hide_owner_handle(owner);
+}
+
+pub(crate) fn refresh_after_commit() -> bool {
+    sync()
+}
+
+fn hide_owner_handle(owner: NodeHandle) {
+    let should_hide = FOCUS_ADORNER_STATE.with(|slot| slot.borrow().active_owner == Some(owner));
+    if !should_hide {
+        return;
+    }
+    FOCUS_ADORNER_STATE.with(|slot| {
+        let mut state = slot.borrow_mut();
+        state.active_owner = None;
+        state.active_style = None;
+    });
+    hide();
+}
+
+fn sync() -> bool {
+    let owner = FOCUS_ADORNER_STATE.with(|slot| slot.borrow().active_owner);
+    let style = FOCUS_ADORNER_STATE.with(|slot| slot.borrow().active_style);
+    let (Some(owner), Some(style)) = (owner, style) else {
+        return hide();
+    };
+    let (Some(host_root), Some(ring_node)) = FOCUS_ADORNER_STATE.with(|slot| {
+        let state = slot.borrow();
+        (state.host_root.clone(), state.ring_node.clone())
+    }) else {
+        return false;
+    };
+    if owner == NodeHandle::INVALID || host_root.handle() == NodeHandle::INVALID {
+        return hide();
+    }
+    let Some(ring_rect) = resolve_ring_rect(owner) else {
+        return hide();
+    };
+    let Some(visible_rect) = resolve_visible_rect(ring_rect) else {
+        return hide();
+    };
+    let color = current_theme().colors.focus_ring;
+    let mut changed = false;
+    FOCUS_ADORNER_STATE.with(|slot| {
+        let mut state = slot.borrow_mut();
+        if !state.attached {
+            host_root.child(&ring_node);
+            state.attached = true;
+            changed = true;
+        }
+        let relative_ring_x = ring_rect.x - visible_rect.x;
+        let relative_ring_y = ring_rect.y - visible_rect.y;
+        if visible_rect.x != state.last_host_x
+            || visible_rect.y != state.last_host_y
+            || visible_rect.width != state.last_host_width
+            || visible_rect.height != state.last_host_height
+            || relative_ring_x != state.last_ring_x
+            || relative_ring_y != state.last_ring_y
+            || ring_rect.width != state.last_ring_width
+            || ring_rect.height != state.last_ring_height
+        {
+            host_root.position(visible_rect.x, visible_rect.y);
+            host_root.width(visible_rect.width, Unit::Pixel);
+            host_root.height(visible_rect.height, Unit::Pixel);
+            ring_node.position(relative_ring_x, relative_ring_y);
+            ring_node.width(ring_rect.width, Unit::Pixel);
+            ring_node.height(ring_rect.height, Unit::Pixel);
+            state.last_host_x = visible_rect.x;
+            state.last_host_y = visible_rect.y;
+            state.last_host_width = visible_rect.width;
+            state.last_host_height = visible_rect.height;
+            state.last_ring_x = relative_ring_x;
+            state.last_ring_y = relative_ring_y;
+            state.last_ring_width = ring_rect.width;
+            state.last_ring_height = ring_rect.height;
+            changed = true;
+        }
+        if color != state.last_color
+            || style.top_left_radius != state.last_top_left_radius
+            || style.top_right_radius != state.last_top_right_radius
+            || style.bottom_right_radius != state.last_bottom_right_radius
+            || style.bottom_left_radius != state.last_bottom_left_radius
+        {
+            ring_node.corners(
+                style.top_left_radius,
+                style.top_right_radius,
+                style.bottom_right_radius,
+                style.bottom_left_radius,
+            );
+            ring_node.border(STANDARD_FOCUS_RING_WIDTH, color);
+            state.last_color = color;
+            state.last_top_left_radius = style.top_left_radius;
+            state.last_top_right_radius = style.top_right_radius;
+            state.last_bottom_right_radius = style.bottom_right_radius;
+            state.last_bottom_left_radius = style.bottom_left_radius;
+            changed = true;
+        }
+    });
+    changed
+}
+
+fn hide() -> bool {
+    FOCUS_ADORNER_STATE.with(|slot| {
+        let mut state = slot.borrow_mut();
+        let (Some(host_root), Some(ring_node)) = (state.host_root.clone(), state.ring_node.clone())
+        else {
+            state.attached = false;
+            state.reset_cached_geometry();
+            return false;
+        };
+        if !state.attached {
+            state.attached = false;
+            state.reset_cached_geometry();
+            return false;
+        }
+        host_root.remove_child(&ring_node);
+        host_root.position(0.0, 0.0);
+        host_root.width(0.0, Unit::Pixel);
+        host_root.height(0.0, Unit::Pixel);
+        state.attached = false;
+        state.reset_cached_geometry();
+        true
+    })
+}
+
+fn resolve_ring_rect(owner: NodeHandle) -> Option<FocusAdornerRect> {
+    let bounds = ui::get_bounds(owner.raw())?;
+    Some(FocusAdornerRect {
+        x: bounds[0] - STANDARD_FOCUS_RING_OUTSET,
+        y: bounds[1] - STANDARD_FOCUS_RING_OUTSET,
+        width: bounds[2] + (STANDARD_FOCUS_RING_OUTSET * 2.0),
+        height: bounds[3] + (STANDARD_FOCUS_RING_OUTSET * 2.0),
+    })
+}
+
+fn resolve_visible_rect(ring_rect: FocusAdornerRect) -> Option<FocusAdornerRect> {
+    let min_x = ring_rect.x.max(0.0);
+    let min_y = ring_rect.y.max(0.0);
+    let max_x = (ring_rect.x + ring_rect.width).min(ui::get_viewport_width());
+    let max_y = (ring_rect.y + ring_rect.height).min(ui::get_viewport_height());
+    let width = max_x - min_x;
+    let height = max_y - min_y;
+    if width <= 0.0 || height <= 0.0 {
+        return None;
+    }
+    Some(FocusAdornerRect {
+        x: min_x,
+        y: min_y,
+        width,
+        height,
+    })
+}

package/src/focus_visibility.rs

@@ -0,0 +1,121 @@
+use crate::ffi::{KeyEventType, KeyModifier, PointerEventType};
+use crate::signal::{Callback, Signal, SubscriptionGuard};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct FocusVisibilityState {
+    signal: Signal<bool>,
+}
+
+thread_local! {
+    static FOCUS_VISIBILITY_STATE: RefCell<FocusVisibilityState> = RefCell::new(FocusVisibilityState {
+        signal: Signal::new(true),
+    });
+}
+
+fn current() -> bool {
+    FOCUS_VISIBILITY_STATE.with(|slot| slot.borrow().signal.get())
+}
+
+fn set(next: bool) {
+    let callbacks = FOCUS_VISIBILITY_STATE.with(|slot| slot.borrow_mut().signal.set(next));
+    if let Some(callbacks) = callbacks {
+        for callback in callbacks {
+            callback();
+        }
+    }
+}
+
+fn is_modifier_key(key: &str) -> bool {
+    matches!(key, "Shift" | "Control" | "Alt" | "Meta")
+}
+
+fn has_non_shift_modifier(modifiers: u32) -> bool {
+    (modifiers
+        & ((KeyModifier::Ctrl as u32) | (KeyModifier::Alt as u32) | (KeyModifier::Meta as u32)))
+        != 0
+}
+
+fn is_caret_navigation_key(key: &str) -> bool {
+    matches!(
+        key,
+        "ArrowLeft"
+            | "ArrowRight"
+            | "ArrowUp"
+            | "ArrowDown"
+            | "Home"
+            | "End"
+            | "PageUp"
+            | "PageDown"
+    )
+}
+
+pub(crate) fn keyboard_focus_visible() -> bool {
+    current()
+}
+
+pub(crate) fn subscribe(handler: impl Fn(bool) + 'static) -> SubscriptionGuard {
+    handler(current());
+    FOCUS_VISIBILITY_STATE.with(|slot| {
+        let callback: Callback = Rc::new(move || handler(current()));
+        slot.borrow_mut().signal.subscribe(callback)
+    })
+}
+
+pub(crate) fn show_keyboard_focus_for_pointer_event(event_type: PointerEventType) {
+    if event_type == PointerEventType::Down {
+        set(false);
+    }
+}
+
+pub fn show_keyboard_focus_for_key_event(event_type: KeyEventType, key: &str, modifiers: u32) {
+    if event_type != KeyEventType::Down {
+        return;
+    }
+    if is_modifier_key(key) {
+        return;
+    }
+    if has_non_shift_modifier(modifiers) {
+        return;
+    }
+    if is_caret_navigation_key(key) {
+        return;
+    }
+    if key == "Escape" {
+        set(false);
+        return;
+    }
+    set(true);
+}
+
+pub(crate) fn reset_keyboard_focus_visibility() {
+    set(true);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pointer_down_hides_keyboard_focus_visibility() {
+        reset_keyboard_focus_visibility();
+        show_keyboard_focus_for_pointer_event(PointerEventType::Down);
+        assert!(!keyboard_focus_visible());
+    }
+
+    #[test]
+    fn regular_key_shows_keyboard_focus_visibility() {
+        reset_keyboard_focus_visibility();
+        show_keyboard_focus_for_pointer_event(PointerEventType::Down);
+        show_keyboard_focus_for_key_event(KeyEventType::Down, "Tab", 0);
+        assert!(keyboard_focus_visible());
+    }
+
+    #[test]
+    fn modifier_key_does_not_show_keyboard_focus_visibility() {
+        reset_keyboard_focus_visibility();
+        show_keyboard_focus_for_pointer_event(PointerEventType::Down);
+        show_keyboard_focus_for_key_event(KeyEventType::Down, "Shift", 0);
+        assert!(!keyboard_focus_visible());
+    }
+}

package/src/frame_scheduler.rs

@@ -0,0 +1,159 @@
+use crate::bindings::ui;
+use std::cell::{Cell, RefCell};
+
+type LoadedCallback = Box<dyn FnOnce(LoadedEventArgs)>;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct LoadedEventArgs;
+
+impl LoadedEventArgs {
+    pub const EMPTY: Self = Self;
+}
+
+thread_local! {
+    static NEEDS_COMMIT: Cell<bool> = const { Cell::new(false) };
+    static FLUSH_SCHEDULED: Cell<bool> = const { Cell::new(false) };
+    static DID_FIRST_COMMIT: Cell<bool> = const { Cell::new(false) };
+    static LOADED_CALLBACKS: RefCell<Vec<LoadedCallback>> = const { RefCell::new(Vec::new()) };
+}
+
+pub fn mark_needs_commit() {
+    NEEDS_COMMIT.with(|needs_commit| needs_commit.set(true));
+    let already_scheduled = FLUSH_SCHEDULED.with(|scheduled| {
+        let already_scheduled = scheduled.get();
+        if !already_scheduled {
+            scheduled.set(true);
+        }
+        already_scheduled
+    });
+    if !already_scheduled {
+        ui::request_render();
+    }
+}
+
+pub fn on_loaded(callback: impl FnOnce(LoadedEventArgs) + 'static) {
+    if DID_FIRST_COMMIT.with(Cell::get) {
+        callback(LoadedEventArgs::EMPTY);
+        return;
+    }
+    LOADED_CALLBACKS.with(|callbacks| callbacks.borrow_mut().push(Box::new(callback)));
+}
+
+pub(crate) fn fire_loaded_callbacks() {
+    if DID_FIRST_COMMIT.with(Cell::get) {
+        return;
+    }
+    DID_FIRST_COMMIT.with(|did_first_commit| did_first_commit.set(true));
+    let callbacks = LOADED_CALLBACKS.with(|callbacks| std::mem::take(&mut *callbacks.borrow_mut()));
+    for callback in callbacks {
+        callback(LoadedEventArgs::EMPTY);
+    }
+}
+
+pub(crate) fn flush_commit() -> bool {
+    FLUSH_SCHEDULED.with(|scheduled| scheduled.set(false));
+    let needs_commit = NEEDS_COMMIT.with(|slot| {
+        let needs_commit = slot.get();
+        if needs_commit {
+            slot.set(false);
+        }
+        needs_commit
+    });
+    if !needs_commit {
+        return false;
+    }
+    ui::commit_frame();
+    true
+}
+
+pub(crate) fn reset_commit_state() {
+    NEEDS_COMMIT.with(|needs_commit| needs_commit.set(false));
+    FLUSH_SCHEDULED.with(|scheduled| scheduled.set(false));
+    DID_FIRST_COMMIT.with(|did_first_commit| did_first_commit.set(false));
+    LOADED_CALLBACKS.with(|callbacks| callbacks.borrow_mut().clear());
+}
+
+pub(crate) fn reset_commit_state_preserving_loaded_callbacks() {
+    NEEDS_COMMIT.with(|needs_commit| needs_commit.set(false));
+    FLUSH_SCHEDULED.with(|scheduled| scheduled.set(false));
+    DID_FIRST_COMMIT.with(|did_first_commit| did_first_commit.set(false));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ffi::{self, Call};
+    use std::cell::Cell;
+    use std::rc::Rc;
+
+    #[test]
+    fn on_loaded_fires_once_and_late_registration_fires_immediately() {
+        reset_commit_state();
+        let count = Rc::new(Cell::new(0));
+        on_loaded({
+            let count = count.clone();
+            move |_| count.set(count.get() + 1)
+        });
+
+        fire_loaded_callbacks();
+        fire_loaded_callbacks();
+        assert_eq!(count.get(), 1);
+
+        on_loaded({
+            let count = count.clone();
+            move |_| count.set(count.get() + 1)
+        });
+        assert_eq!(count.get(), 2);
+    }
+
+    #[test]
+    fn mark_needs_commit_coalesces_render_requests_until_flush() {
+        reset_commit_state();
+        ffi::test::reset();
+
+        mark_needs_commit();
+        mark_needs_commit();
+        let calls = ffi::test::take_calls();
+        assert_eq!(
+            calls
+                .iter()
+                .filter(|call| matches!(call, Call::RequestRender))
+                .count(),
+            1
+        );
+
+        assert!(flush_commit());
+        let _ = ffi::test::take_calls();
+        mark_needs_commit();
+        let calls = ffi::test::take_calls();
+        assert_eq!(
+            calls
+                .iter()
+                .filter(|call| matches!(call, Call::RequestRender))
+                .count(),
+            1
+        );
+    }
+
+    #[test]
+    fn flush_commit_noops_without_pending_work() {
+        reset_commit_state();
+        ffi::test::reset();
+
+        assert!(!flush_commit());
+        assert!(ffi::test::take_calls()
+            .iter()
+            .all(|call| !matches!(call, Call::CommitFrame)));
+
+        mark_needs_commit();
+        assert!(flush_commit());
+        assert!(ffi::test::take_calls()
+            .iter()
+            .any(|call| matches!(call, Call::CommitFrame)));
+
+        assert!(!flush_commit());
+        assert!(ffi::test::take_calls()
+            .iter()
+            .all(|call| !matches!(call, Call::CommitFrame)));
+    }
+}

package/src/frame_signal.rs

@@ -0,0 +1,64 @@
+use crate::signal::{Callback, Signal, SubscriptionGuard};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+#[derive(Clone, Copy)]
+pub struct FrameTimeSignalHandle;
+
+thread_local! {
+    static FRAME_TIME_SIGNAL: RefCell<Signal<f64>> = RefCell::new(Signal::new(0.0));
+}
+
+impl FrameTimeSignalHandle {
+    pub fn value(&self) -> f64 {
+        FRAME_TIME_SIGNAL.with(|slot| slot.borrow().get())
+    }
+
+    pub fn subscribe(&self, handler: impl Fn(f64) + 'static) -> SubscriptionGuard {
+        handler(self.value());
+        FRAME_TIME_SIGNAL.with(|slot| {
+            let callback: Callback = Rc::new(move || handler(frame_time_signal().value()));
+            slot.borrow_mut().subscribe(callback)
+        })
+    }
+}
+
+pub fn frame_time_signal() -> FrameTimeSignalHandle {
+    FrameTimeSignalHandle
+}
+
+pub(crate) fn set_frame_time(timestamp_ms: f64) {
+    FRAME_TIME_SIGNAL.with(|slot| {
+        let callbacks = slot.borrow_mut().set(timestamp_ms);
+        if let Some(callbacks) = callbacks {
+            for callback in callbacks {
+                callback();
+            }
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{frame_time_signal, set_frame_time};
+    use std::cell::Cell;
+    use std::rc::Rc;
+
+    #[test]
+    fn updates_frame_time_signal_and_notifies_subscribers() {
+        let count = Rc::new(Cell::new(0));
+        let seen = Rc::new(Cell::new(0.0));
+        let count_for_handler = count.clone();
+        let seen_for_handler = seen.clone();
+        let _guard = frame_time_signal().subscribe(move |value| {
+            count_for_handler.set(count_for_handler.get() + 1);
+            seen_for_handler.set(value);
+        });
+
+        set_frame_time(1234.5);
+
+        assert_eq!(frame_time_signal().value(), 1234.5);
+        assert_eq!(seen.get(), 1234.5);
+        assert!(count.get() >= 2);
+    }
+}