@effindomv2/fui-rs 0.1.3

package/src/controls/nav_link.rs

@@ -0,0 +1,395 @@
+use super::*;
+use crate::bindings::ui;
+use crate::event::PointerType;
+use crate::ffi::{CursorStyle, HandleValue, SemanticRole};
+use crate::navigation;
+use crate::node::{text, NodeHandle, NodeRef, WeakFlexBox};
+use crate::platform;
+use crate::signal::SubscriptionGuard;
+use crate::theme::{current_theme, subscribe};
+use crate::{focus_adorner, focus_visibility};
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+thread_local! {
+    static ACTIVE_PREVIEW_OWNER: Cell<u64> = const { Cell::new(HandleValue::Invalid as u64) };
+}
+
+fn is_primary_activation_pointer(event: &PointerEventArgs) -> bool {
+    event.button == 0
+        || event.pointer_type == PointerType::Touch
+        || event.pointer_type == PointerType::Pen
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct NavigateEventArgs {
+    pub path: String,
+}
+
+type NavigateCallback = Rc<dyn Fn(NavigateEventArgs)>;
+
+#[derive(Clone)]
+pub struct NavLink {
+    root: FlexBox,
+    label: TextNode,
+    href: Rc<RefCell<String>>,
+    open_in_new_tab: Rc<Cell<bool>>,
+    navigate: Rc<RefCell<Option<NavigateCallback>>>,
+    hovered: Rc<Cell<bool>>,
+    focused: Rc<Cell<bool>>,
+    pointer_pressed: Rc<Cell<bool>>,
+    pointer_pressed_open_in_new_tab: Rc<Cell<bool>>,
+    enter_pressed: Rc<Cell<bool>>,
+    enter_pressed_open_in_new_tab: Rc<Cell<bool>>,
+    preview_pinned_for_context_menu: Rc<Cell<bool>>,
+    theme_guard: Rc<RefCell<Option<SubscriptionGuard>>>,
+    focus_visibility_guard: Rc<RefCell<Option<SubscriptionGuard>>>,
+}
+
+impl NavLink {
+    pub fn new(href: impl Into<String>) -> Self {
+        let href = href.into();
+        Self::with_label(href.clone(), href)
+    }
+
+    pub fn with_label(href: impl Into<String>, label: impl Into<String>) -> Self {
+        let href = href.into();
+        let label = label.into();
+        let root = row();
+        let label_node = text(&label);
+        let theme = current_theme();
+        label_node
+            .font_family(theme.fonts.body_family.clone())
+            .font_size(15.0)
+            .text_color(theme.colors.accent)
+            .cursor(CursorStyle::Pointer);
+        root.justify_content(JustifyContent::Start)
+            .align_items(AlignItems::Center)
+            .interactive(true)
+            .focusable(true, 0)
+            .cursor(CursorStyle::Pointer)
+            .semantic_role(SemanticRole::Link)
+            .semantic_label(label)
+            .reflect_semantic_disabled_from_enabled()
+            .child(&label_node);
+        root.retained_node_ref()
+            .set_link_url_for_routing(Some(href.clone()));
+
+        let link = Self {
+            root,
+            label: label_node,
+            href: Rc::new(RefCell::new(href)),
+            open_in_new_tab: Rc::new(Cell::new(false)),
+            navigate: Rc::new(RefCell::new(None)),
+            hovered: Rc::new(Cell::new(false)),
+            focused: Rc::new(Cell::new(false)),
+            pointer_pressed: Rc::new(Cell::new(false)),
+            pointer_pressed_open_in_new_tab: Rc::new(Cell::new(false)),
+            enter_pressed: Rc::new(Cell::new(false)),
+            enter_pressed_open_in_new_tab: Rc::new(Cell::new(false)),
+            preview_pinned_for_context_menu: Rc::new(Cell::new(false)),
+            theme_guard: Rc::new(RefCell::new(None)),
+            focus_visibility_guard: Rc::new(RefCell::new(None)),
+        };
+        let node_ref = link.root.retained_node_ref();
+        let pin_target = link.event_target();
+        let release_target = link.event_target();
+        node_ref.set_link_preview_handlers_for_routing(
+            Some(Rc::new(move || {
+                pin_target.pin_preview_for_context_menu();
+            })),
+            Some(Rc::new(move || {
+                release_target.release_preview_for_context_menu();
+            })),
+        );
+        link.install_subscriptions();
+        link.bind_events();
+        link.sync_visual_state();
+        link.sync_focus_chrome();
+        link
+    }
+
+    fn bind_events(&self) {
+        let target = self.event_target();
+        self.root.on_pointer_enter(move |_event| {
+            target.hovered.set(true);
+            target.sync_visual_state();
+            target.show_preview();
+        });
+        let target = self.event_target();
+        self.root.on_pointer_leave(move |_event| {
+            target.hovered.set(false);
+            target.pointer_pressed.set(false);
+            target.pointer_pressed_open_in_new_tab.set(false);
+            target.sync_visual_state();
+            if !target.focused.get() && !target.preview_pinned_for_context_menu.get() {
+                target.hide_preview();
+            }
+        });
+        let target = self.event_target();
+        self.root.on_pointer_down(move |event| {
+            if !is_primary_activation_pointer(event) {
+                target.pointer_pressed.set(false);
+                target.pointer_pressed_open_in_new_tab.set(false);
+                return;
+            }
+            target.pointer_pressed.set(true);
+            target
+                .pointer_pressed_open_in_new_tab
+                .set(target.should_open_in_new_tab(event.modifiers));
+            event.handled = true;
+        });
+        let target = self.event_target();
+        self.root.on_pointer_up(move |event| {
+            if target.pointer_pressed.replace(false) && is_primary_activation_pointer(event) {
+                let open_in_new_tab = target.pointer_pressed_open_in_new_tab.get()
+                    || target.should_open_in_new_tab(event.modifiers);
+                target.activate(open_in_new_tab);
+                event.handled = true;
+            }
+            target.pointer_pressed_open_in_new_tab.set(false);
+        });
+        let target = self.event_target();
+        self.root.on_key_down(move |event| {
+            if !target.should_handle_enter_key(event.modifiers) || event.key != "Enter" {
+                return;
+            }
+            if target.enter_pressed.get() {
+                event.handled = true;
+                return;
+            }
+            target.enter_pressed.set(true);
+            target
+                .enter_pressed_open_in_new_tab
+                .set(target.should_open_in_new_tab(event.modifiers));
+            event.handled = true;
+        });
+        let target = self.event_target();
+        self.root.on_key_up(move |event| {
+            if !target.should_handle_enter_key(event.modifiers) || event.key != "Enter" {
+                return;
+            }
+            if target.enter_pressed.replace(false) {
+                let open_in_new_tab = target.enter_pressed_open_in_new_tab.get()
+                    || target.should_open_in_new_tab(event.modifiers);
+                target.activate(open_in_new_tab);
+                event.handled = true;
+            }
+            target.enter_pressed_open_in_new_tab.set(false);
+        });
+        let target = self.event_target();
+        self.root.on_focus_changed(move |event| {
+            target.focused.set(event.focused);
+            if !event.focused {
+                target.enter_pressed.set(false);
+                target.enter_pressed_open_in_new_tab.set(false);
+            }
+            target.sync_focus_chrome();
+            if event.focused {
+                target.show_preview();
+            } else if !target.hovered.get() && !target.preview_pinned_for_context_menu.get() {
+                target.hide_preview();
+            }
+        });
+    }
+
+    fn install_subscriptions(&self) {
+        let target = self.event_target();
+        *self.theme_guard.borrow_mut() = Some(subscribe(move |_theme| {
+            target.sync_visual_state();
+            target.sync_focus_chrome();
+        }));
+        let target = self.event_target();
+        *self.focus_visibility_guard.borrow_mut() =
+            Some(focus_visibility::subscribe(move |_visible| {
+                target.sync_focus_chrome();
+            }));
+    }
+
+    fn event_target(&self) -> NavLinkEventTarget {
+        NavLinkEventTarget {
+            weak_root: self.root.downgrade(),
+            label: self.label.retained_node_ref(),
+            href: self.href.clone(),
+            open_in_new_tab: self.open_in_new_tab.clone(),
+            navigate: self.navigate.clone(),
+            hovered: self.hovered.clone(),
+            focused: self.focused.clone(),
+            pointer_pressed: self.pointer_pressed.clone(),
+            pointer_pressed_open_in_new_tab: self.pointer_pressed_open_in_new_tab.clone(),
+            enter_pressed: self.enter_pressed.clone(),
+            enter_pressed_open_in_new_tab: self.enter_pressed_open_in_new_tab.clone(),
+            preview_pinned_for_context_menu: self.preview_pinned_for_context_menu.clone(),
+        }
+    }
+
+    pub fn href(&self) -> String {
+        self.href.borrow().clone()
+    }
+
+    pub fn href_to(&self, href: impl Into<String>) -> &Self {
+        let href = href.into();
+        *self.href.borrow_mut() = href.clone();
+        self.root
+            .retained_node_ref()
+            .set_link_url_for_routing(Some(href));
+        if self.focused.get() || self.hovered.get() || self.preview_pinned_for_context_menu.get() {
+            self.event_target().show_preview();
+        }
+        self
+    }
+
+    pub fn text(&self, value: impl Into<String>) -> &Self {
+        let value = value.into();
+        self.label.text(value.clone());
+        self.root.semantic_label(value);
+        self
+    }
+
+    pub fn open_in_new_tab(&self, open: bool) -> &Self {
+        self.open_in_new_tab.set(open);
+        self
+    }
+
+    pub fn on_navigate(&self, handler: impl Fn(NavigateEventArgs) + 'static) -> &Self {
+        *self.navigate.borrow_mut() = Some(Rc::new(handler));
+        self
+    }
+
+    fn sync_visual_state(&self) {
+        self.event_target().sync_visual_state();
+    }
+
+    fn sync_focus_chrome(&self) {
+        self.event_target().sync_focus_chrome();
+    }
+}
+
+impl Node for NavLink {
+    fn retained_node_ref(&self) -> NodeRef {
+        self.root.retained_node_ref()
+    }
+
+    fn build_self(&self) {
+        self.root.build_self();
+    }
+}
+
+impl HasFlexBoxRoot for NavLink {
+    fn flex_box_root(&self) -> &FlexBox {
+        &self.root
+    }
+}
+
+#[derive(Clone)]
+struct NavLinkEventTarget {
+    weak_root: WeakFlexBox,
+    label: NodeRef,
+    href: Rc<RefCell<String>>,
+    open_in_new_tab: Rc<Cell<bool>>,
+    navigate: Rc<RefCell<Option<NavigateCallback>>>,
+    hovered: Rc<Cell<bool>>,
+    focused: Rc<Cell<bool>>,
+    pointer_pressed: Rc<Cell<bool>>,
+    pointer_pressed_open_in_new_tab: Rc<Cell<bool>>,
+    enter_pressed: Rc<Cell<bool>>,
+    enter_pressed_open_in_new_tab: Rc<Cell<bool>>,
+    preview_pinned_for_context_menu: Rc<Cell<bool>>,
+}
+
+impl NavLinkEventTarget {
+    fn is_enabled(&self) -> bool {
+        self.weak_root
+            .upgrade()
+            .map(|root| root.retained_node_ref().is_enabled_for_routing())
+            .unwrap_or(false)
+    }
+
+    fn activate(&self, open_in_new_tab: bool) {
+        let href = self.href.borrow().clone();
+        navigation::navigate_to(&href, open_in_new_tab);
+        if let Some(callback) = self.navigate.borrow().clone() {
+            callback(NavigateEventArgs { path: href });
+        }
+    }
+
+    fn should_open_in_new_tab(&self, modifiers: u32) -> bool {
+        self.open_in_new_tab.get() || platform::has_primary_shortcut_modifier(modifiers)
+    }
+
+    fn should_handle_enter_key(&self, modifiers: u32) -> bool {
+        self.is_enabled() && (modifiers == 0 || platform::has_primary_shortcut_modifier(modifiers))
+    }
+
+    fn show_preview(&self) {
+        let Some(root) = self.weak_root.upgrade() else {
+            return;
+        };
+        let handle = root.handle().raw();
+        if handle == HandleValue::Invalid as u64 {
+            return;
+        }
+        let href = self.href.borrow().clone();
+        let bytes = href.as_bytes();
+        unsafe {
+            crate::ffi::fui_show_url_preview(
+                if bytes.is_empty() {
+                    0
+                } else {
+                    bytes.as_ptr() as usize
+                },
+                bytes.len() as u32,
+            )
+        };
+        ACTIVE_PREVIEW_OWNER.with(|owner| owner.set(handle));
+    }
+
+    fn hide_preview(&self) {
+        let Some(root) = self.weak_root.upgrade() else {
+            return;
+        };
+        let handle = root.handle().raw();
+        if !ACTIVE_PREVIEW_OWNER.with(|owner| owner.get() == handle) {
+            return;
+        }
+        ACTIVE_PREVIEW_OWNER.with(|owner| owner.set(HandleValue::Invalid as u64));
+        unsafe { crate::ffi::fui_hide_url_preview() };
+    }
+
+    fn pin_preview_for_context_menu(&self) {
+        self.preview_pinned_for_context_menu.set(true);
+        self.show_preview();
+    }
+
+    fn release_preview_for_context_menu(&self) {
+        if !self.preview_pinned_for_context_menu.replace(false) {
+            return;
+        }
+        if !self.hovered.get() && !self.focused.get() {
+            self.hide_preview();
+        }
+    }
+
+    fn sync_visual_state(&self) {
+        let color = if self.hovered.get() {
+            current_theme().colors.accent_hovered
+        } else {
+            current_theme().colors.accent
+        };
+        let label = &self.label;
+        if label.handle() != NodeHandle::INVALID {
+            ui::set_text_color(label.handle().raw(), color);
+        }
+    }
+
+    fn sync_focus_chrome(&self) {
+        let Some(root) = self.weak_root.upgrade() else {
+            return;
+        };
+        if self.focused.get() && self.is_enabled() && focus_visibility::keyboard_focus_visible() {
+            focus_adorner::show_standard(&root, current_theme().spacing.sm);
+            return;
+        }
+        focus_adorner::hide_owner(&root);
+    }
+}

package/src/controls/popup.rs

@@ -0,0 +1,191 @@
+use super::*;
+use crate::ffi::{FlexDirection, PositionType, Unit};
+use crate::node::{portal, Border, Child};
+use crate::popup_presenter::{PopupPlacement, PopupPresenter};
+use std::cell::Cell;
+
+#[derive(Clone)]
+pub struct Popup {
+    root: FlexBox,
+    surface_node: FlexBox,
+    presenter: PopupPresenter,
+    dismiss_on_backdrop_click: Rc<Cell<bool>>,
+}
+
+impl Default for Popup {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Popup {
+    pub fn new() -> Self {
+        let root = portal();
+        let surface_node = flex_box();
+        surface_node
+            .position_type(PositionType::Absolute)
+            .flex_direction(FlexDirection::Column);
+        let presenter = PopupPresenter::new(root.clone(), surface_node.clone());
+        root.position_type(PositionType::Absolute)
+            .position(0.0, 0.0)
+            .width(100.0, Unit::Percent)
+            .height(100.0, Unit::Percent);
+        let dismiss_on_backdrop_click = Rc::new(Cell::new(true));
+        let dismiss_flag = dismiss_on_backdrop_click.clone();
+        let presenter_target = presenter.event_target();
+        presenter
+            .overlay_node()
+            .interactive(true)
+            .on_click(move |_event| {
+                if dismiss_flag.get() {
+                    presenter_target.hide();
+                }
+            });
+        Self {
+            root,
+            surface_node,
+            presenter,
+            dismiss_on_backdrop_click,
+        }
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.presenter.is_open()
+    }
+
+    pub fn surface(&self) -> FlexBox {
+        self.surface_node.clone()
+    }
+
+    pub fn placement(&self, value: PopupPlacement) -> &Self {
+        self.presenter.placement(value);
+        self
+    }
+
+    pub fn edge_padding(&self, value: f32) -> &Self {
+        self.presenter.edge_padding(value);
+        self
+    }
+
+    pub fn anchor_gap(&self, value: f32) -> &Self {
+        self.presenter.anchor_gap(value);
+        self
+    }
+
+    pub fn dismiss_on_backdrop_click(&self, flag: bool) -> &Self {
+        self.dismiss_on_backdrop_click.set(flag);
+        self
+    }
+
+    pub fn backdrop_color(&self, color: u32) -> &Self {
+        self.presenter.backdrop_color(color);
+        self
+    }
+
+    pub fn background_blur(&self, sigma: f32) -> &Self {
+        self.presenter.background_blur(sigma);
+        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
+    }
+
+    pub fn panel_color(&self, color: u32) -> &Self {
+        self.surface_node.bg_color(color);
+        self
+    }
+
+    pub fn panel_background_blur(&self, sigma: f32) -> &Self {
+        self.surface_node.background_blur(sigma);
+        self
+    }
+
+    pub fn panel_corner_radius(&self, radius: f32) -> &Self {
+        self.surface_node.corner_radius(radius);
+        self
+    }
+
+    pub fn panel_border(&self, width: f32, color: u32) -> &Self {
+        self.surface_node.border(width, color);
+        self
+    }
+
+    pub fn panel_border_config(&self, border: Border) -> &Self {
+        self.surface_node.border_config(border);
+        self
+    }
+
+    pub fn panel_shadow(
+        &self,
+        color: u32,
+        offset_x: f32,
+        offset_y: f32,
+        blur_sigma: f32,
+        spread: f32,
+    ) -> &Self {
+        self.surface_node
+            .drop_shadow(color, offset_x, offset_y, blur_sigma, spread);
+        self
+    }
+
+    pub fn show_anchored(
+        &self,
+        anchor_x: f32,
+        anchor_y: f32,
+        anchor_width: f32,
+        anchor_height: f32,
+        width: f32,
+        height: f32,
+    ) {
+        self.surface_node.width(width, Unit::Pixel);
+        self.surface_node.height(height, Unit::Pixel);
+        self.presenter.show_anchored(
+            anchor_x,
+            anchor_y,
+            anchor_width,
+            anchor_height,
+            width,
+            height,
+        );
+    }
+
+    pub fn show_at_point(&self, x: f32, y: f32, width: f32, height: f32) {
+        self.surface_node.width(width, Unit::Pixel);
+        self.surface_node.height(height, Unit::Pixel);
+        self.presenter.show_at_point(x, y, width, height);
+    }
+
+    pub fn hide(&self) {
+        self.presenter.hide();
+    }
+}
+
+impl Node for Popup {
+    fn retained_node_ref(&self) -> NodeRef {
+        self.root.retained_node_ref()
+    }
+
+    fn build_self(&self) {
+        self.root.build_self();
+    }
+
+    fn dispose(&self) {
+        self.presenter.dispose();
+        self.root.dispose();
+    }
+}