@effindomv2/fui-rs 0.1.3

package/src/controls/form.rs

@@ -0,0 +1,229 @@
+use super::Button;
+use crate::event;
+use crate::ffi::{FlexDirection, KeyEventType, SemanticRole};
+use crate::node::{flex_box, Child, FlexBox, Node, NodeRef};
+use std::any::Any;
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub struct Form {
+    shared: Rc<FormShared>,
+}
+
+struct FormShared {
+    root: FlexBox,
+    default_button: RefCell<Option<Button>>,
+    cancel_button: RefCell<Option<Button>>,
+    key_filter_token: Cell<u32>,
+    armed_key: RefCell<Option<String>>,
+    armed_button: RefCell<Option<Button>>,
+}
+
+impl Default for Form {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Form {
+    pub fn new() -> Self {
+        let root = flex_box();
+        root.flex_direction(FlexDirection::Column)
+            .semantic_role(SemanticRole::Form);
+        let form = Self {
+            shared: Rc::new(FormShared {
+                root,
+                default_button: RefCell::new(None),
+                cancel_button: RefCell::new(None),
+                key_filter_token: Cell::new(0),
+                armed_key: RefCell::new(None),
+                armed_button: RefCell::new(None),
+            }),
+        };
+        form.bind_events();
+        form
+    }
+
+    pub fn default_btn(&self, button: &Button) -> &Self {
+        self.shared
+            .default_button
+            .borrow_mut()
+            .replace(button.clone());
+        self
+    }
+
+    pub fn cancel_btn(&self, button: &Button) -> &Self {
+        self.shared
+            .cancel_button
+            .borrow_mut()
+            .replace(button.clone());
+        self
+    }
+
+    pub fn child<T: Node>(&self, node: &T) -> &Self {
+        self.shared.root.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.shared
+                .root
+                .retained_node_ref()
+                .append_child_ref(&node.into().node_ref);
+        }
+        self
+    }
+
+    pub fn activate(&self) {
+        if self.shared.key_filter_token.get() != 0
+            || (self.shared.default_button.borrow().is_none()
+                && self.shared.cancel_button.borrow().is_none())
+        {
+            return;
+        }
+        let weak = Rc::downgrade(&self.shared);
+        let token = event::push_key_filter(move |event_type, key, modifiers| {
+            let Some(shared) = weak.upgrade() else {
+                return false;
+            };
+            shared.handle_global_key_event(event_type, key, modifiers)
+        });
+        self.shared.key_filter_token.set(token);
+    }
+
+    pub fn deactivate(&self) {
+        self.shared.deactivate();
+    }
+
+    fn bind_events(&self) {
+        let weak = Rc::downgrade(&self.shared);
+        self.shared.root.on_key_down(move |event| {
+            let Some(shared) = weak.upgrade() else {
+                return;
+            };
+            if shared.handle_global_key_event(
+                KeyEventType::Down,
+                event.key.as_str(),
+                event.modifiers,
+            ) {
+                event.handled = true;
+            }
+        });
+        let weak = Rc::downgrade(&self.shared);
+        self.shared.root.on_key_up(move |event| {
+            let Some(shared) = weak.upgrade() else {
+                return;
+            };
+            if shared.handle_global_key_event(KeyEventType::Up, event.key.as_str(), event.modifiers)
+            {
+                event.handled = true;
+            }
+        });
+    }
+}
+
+impl Drop for Form {
+    fn drop(&mut self) {
+        if Rc::strong_count(&self.shared) == 1 {
+            self.shared.deactivate();
+        }
+    }
+}
+
+impl FormShared {
+    fn deactivate(&self) {
+        self.cancel_armed_button();
+        let token = self.key_filter_token.replace(0);
+        if token != 0 {
+            event::remove_key_filter(token);
+        }
+    }
+
+    fn handle_global_key_event(&self, event_type: KeyEventType, key: &str, modifiers: u32) -> bool {
+        if key == "Enter" && self.should_defer_enter_to_focused_button(modifiers) {
+            return false;
+        }
+        match event_type {
+            KeyEventType::Down => self.handle_key_down(key),
+            KeyEventType::Up => self.handle_key_up(key),
+        }
+    }
+
+    fn handle_key_down(&self, key: &str) -> bool {
+        let Some(button) = self.resolve_button_for_key(key) else {
+            return false;
+        };
+        if let Some(armed_key) = self.armed_key.borrow().as_ref() {
+            return armed_key == key;
+        }
+        self.armed_key.borrow_mut().replace(key.to_string());
+        self.armed_button.borrow_mut().replace(button.clone());
+        button.begin_press();
+        true
+    }
+
+    fn handle_key_up(&self, key: &str) -> bool {
+        let armed_matches = self
+            .armed_key
+            .borrow()
+            .as_ref()
+            .is_some_and(|armed_key| armed_key == key);
+        if !armed_matches {
+            return false;
+        }
+        let button = self.armed_button.borrow_mut().take();
+        self.armed_key.borrow_mut().take();
+        if let Some(button) = button {
+            button.end_press(true);
+        }
+        true
+    }
+
+    fn cancel_armed_button(&self) {
+        let button = self.armed_button.borrow_mut().take();
+        self.armed_key.borrow_mut().take();
+        if let Some(button) = button {
+            button.cancel_press();
+        }
+    }
+
+    fn resolve_button_for_key(&self, key: &str) -> Option<Button> {
+        match key {
+            "Enter" => self.default_button.borrow().clone(),
+            "Escape" => self.cancel_button.borrow().clone(),
+            _ => None,
+        }
+    }
+
+    fn should_defer_enter_to_focused_button(&self, modifiers: u32) -> bool {
+        if modifiers != 0 {
+            return false;
+        }
+        event::focused_node_is_enabled_button()
+    }
+}
+
+impl Node for Form {
+    fn retained_node_ref(&self) -> NodeRef {
+        self.shared.root.retained_node_ref()
+    }
+
+    fn retained_owner_attachment(&self) -> Option<Rc<dyn Any>> {
+        Some(self.shared.clone())
+    }
+
+    fn build_self(&self) {
+        self.shared.root.build_self();
+    }
+
+    fn dispose(&self) {
+        self.deactivate();
+        self.shared.root.dispose();
+    }
+}

package/src/controls/internal/button_presenter.rs

@@ -0,0 +1,142 @@
+use crate::controls::ButtonColors;
+use crate::ffi::{AlignItems, FlexDirection, JustifyContent};
+use crate::node::{flex_box, FlexBox, TextCore};
+use crate::theme::Theme;
+use crate::{FontStyle, FontWeight};
+use std::rc::Rc;
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct ButtonVisualState {
+    pub hovered: bool,
+    pub pressed: bool,
+    pub focused: bool,
+    pub enabled: bool,
+}
+
+pub trait ButtonPresenter {
+    fn content_root(&self) -> FlexBox;
+    fn label_node(&self) -> TextCore;
+    fn apply(
+        &self,
+        host: &FlexBox,
+        theme: Theme,
+        state: ButtonVisualState,
+        colors: Option<ButtonColors>,
+    );
+}
+
+pub trait ButtonTemplate {
+    fn create(&self) -> Rc<dyn ButtonPresenter>;
+}
+
+#[derive(Clone)]
+pub struct DefaultButtonPresenter {
+    content_root: FlexBox,
+    label_node: TextCore,
+}
+
+impl DefaultButtonPresenter {
+    pub fn new() -> Self {
+        let label_node = TextCore::new("");
+        let content_root = flex_box();
+        content_root
+            .flex_direction(FlexDirection::Row)
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center)
+            .child(&label_node);
+        Self {
+            content_root,
+            label_node,
+        }
+    }
+}
+
+impl ButtonPresenter for DefaultButtonPresenter {
+    fn content_root(&self) -> FlexBox {
+        self.content_root.clone()
+    }
+
+    fn label_node(&self) -> TextCore {
+        self.label_node.clone()
+    }
+
+    fn apply(
+        &self,
+        host: &FlexBox,
+        theme: Theme,
+        state: ButtonVisualState,
+        colors: Option<ButtonColors>,
+    ) {
+        let background = if !state.enabled {
+            colors
+                .and_then(|colors| colors.background)
+                .unwrap_or(theme.colors.accent)
+        } else if state.pressed {
+            colors
+                .and_then(|colors| colors.background_pressed)
+                .or_else(|| colors.and_then(|colors| colors.background_hover))
+                .or_else(|| colors.and_then(|colors| colors.background))
+                .unwrap_or(theme.colors.accent_pressed)
+        } else if state.hovered {
+            colors
+                .and_then(|colors| colors.background_hover)
+                .or_else(|| colors.and_then(|colors| colors.background))
+                .unwrap_or(theme.colors.accent_hovered)
+        } else {
+            colors
+                .and_then(|colors| colors.background)
+                .unwrap_or(theme.colors.accent)
+        };
+        let border = colors
+            .and_then(|colors| colors.border)
+            .unwrap_or(theme.colors.border);
+        let text_color = if !state.enabled {
+            colors
+                .and_then(|colors| colors.text_muted)
+                .or_else(|| colors.and_then(|colors| colors.text_primary))
+                .unwrap_or(theme.colors.text_on_accent)
+        } else {
+            colors
+                .and_then(|colors| colors.text_primary)
+                .unwrap_or(theme.colors.text_on_accent)
+        };
+        host.flex_direction(FlexDirection::Row)
+            .justify_content(JustifyContent::Center)
+            .align_items(AlignItems::Center)
+            .corner_radius(theme.spacing.sm)
+            .border(1.0, border)
+            .padding(
+                theme.spacing.md,
+                theme.spacing.sm,
+                theme.spacing.md,
+                theme.spacing.sm,
+            )
+            .drop_shadow(0x00000000, 0.0, 0.0, 0.0, 0.0)
+            .bg_color(background);
+        self.content_root
+            .flex_direction(FlexDirection::Row)
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+        self.label_node
+            .font_family(theme.fonts.body_family.clone())
+            .font_weight(FontWeight::Regular)
+            .font_style(FontStyle::Normal)
+            .font_size(theme.fonts.size_body)
+            .text_color(text_color);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultButtonTemplate;
+
+impl ButtonTemplate for DefaultButtonTemplate {
+    fn create(&self) -> Rc<dyn ButtonPresenter> {
+        Rc::new(DefaultButtonPresenter::new())
+    }
+}
+
+pub const DEFAULT_BUTTON_TEMPLATE: DefaultButtonTemplate = DefaultButtonTemplate;
+
+pub fn create_default_button_presenter() -> Rc<dyn ButtonPresenter> {
+    Rc::new(DefaultButtonPresenter::new())
+}

package/src/controls/internal/checkbox_indicator_presenter.rs

@@ -0,0 +1,210 @@
+use super::pressable_indicator_presenter::{
+    PressableIndicatorMetrics, PressableIndicatorPresenter, PressableIndicatorVisualState,
+};
+use crate::controls::{LabeledControlColors, LabeledControlSizing};
+use crate::ffi::{AlignItems, JustifyContent, SemanticCheckedState, Unit};
+use crate::node::{flex_box, svg, FlexBox, SvgNode};
+use crate::theme::Theme;
+use std::rc::Rc;
+
+const CHECKBOX_CHECK_SVG_URL: &str = "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='20' viewBox='0 0 14 14'><path d='M2.25 7.15 5.35 10.25 11.75 3.85' fill='none' stroke='%23000000' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'/></svg>";
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CheckboxIndicatorMetrics {
+    pub indicator_size: f32,
+    pub corner_radius: f32,
+    pub check_mark_size: f32,
+}
+
+impl CheckboxIndicatorMetrics {
+    pub const fn new(indicator_size: f32, corner_radius: f32, check_mark_size: f32) -> Self {
+        Self {
+            indicator_size,
+            corner_radius,
+            check_mark_size,
+        }
+    }
+}
+
+const DEFAULT_CHECKBOX_METRICS: CheckboxIndicatorMetrics =
+    CheckboxIndicatorMetrics::new(20.0, 4.0, 16.0);
+
+pub fn resolve_checkbox_metrics(sizing: Option<LabeledControlSizing>) -> CheckboxIndicatorMetrics {
+    let Some(sizing) = sizing else {
+        return DEFAULT_CHECKBOX_METRICS;
+    };
+    if !sizing.has_indicator_size() {
+        return DEFAULT_CHECKBOX_METRICS;
+    }
+    let indicator_size = sizing.indicator_size_px();
+    CheckboxIndicatorMetrics::new(indicator_size, indicator_size * 0.2, indicator_size * 0.8)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct CheckboxIndicatorVisualState {
+    pub checked_state: SemanticCheckedState,
+    pub hovered: bool,
+    pub pressed: bool,
+    pub focused: bool,
+    pub enabled: bool,
+}
+
+impl CheckboxIndicatorVisualState {
+    pub fn new(
+        checked_state: SemanticCheckedState,
+        hovered: bool,
+        pressed: bool,
+        focused: bool,
+        enabled: bool,
+    ) -> Self {
+        Self {
+            checked_state,
+            hovered,
+            pressed,
+            focused,
+            enabled,
+        }
+    }
+
+    pub fn pressable_state(&self) -> PressableIndicatorVisualState {
+        PressableIndicatorVisualState {
+            hovered: self.hovered,
+            pressed: self.pressed,
+            focused: self.focused,
+            enabled: self.enabled,
+        }
+    }
+}
+
+pub trait CheckboxIndicatorPresenter: PressableIndicatorPresenter {
+    fn apply(
+        &self,
+        theme: Theme,
+        state: CheckboxIndicatorVisualState,
+        colors: Option<LabeledControlColors>,
+    );
+}
+
+pub trait CheckboxIndicatorTemplate {
+    fn create(&self, sizing: Option<LabeledControlSizing>) -> Rc<dyn CheckboxIndicatorPresenter>;
+}
+
+#[derive(Clone)]
+pub struct DefaultCheckboxIndicatorPresenter {
+    root: FlexBox,
+    metrics: CheckboxIndicatorMetrics,
+    mark_node: SvgNode,
+}
+
+impl DefaultCheckboxIndicatorPresenter {
+    pub fn new(metrics: CheckboxIndicatorMetrics) -> Self {
+        let root = flex_box();
+        root.width(metrics.indicator_size, Unit::Pixel)
+            .height(metrics.indicator_size, Unit::Pixel)
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+        let mark_host = flex_box();
+        mark_host
+            .fill_size()
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+        let mark_node = svg(0);
+        mark_node
+            .width(metrics.check_mark_size, Unit::Pixel)
+            .height(metrics.check_mark_size, Unit::Pixel);
+        mark_host.child(&mark_node);
+        root.child(&mark_host);
+        Self {
+            root,
+            metrics,
+            mark_node,
+        }
+    }
+}
+
+impl PressableIndicatorPresenter for DefaultCheckboxIndicatorPresenter {
+    fn root(&self) -> FlexBox {
+        self.root.clone()
+    }
+
+    fn metrics(&self) -> PressableIndicatorMetrics {
+        PressableIndicatorMetrics::new(self.metrics.indicator_size, self.metrics.indicator_size)
+    }
+}
+
+impl CheckboxIndicatorPresenter for DefaultCheckboxIndicatorPresenter {
+    fn apply(
+        &self,
+        theme: Theme,
+        state: CheckboxIndicatorVisualState,
+        colors: Option<LabeledControlColors>,
+    ) {
+        let metrics = self.metrics;
+        let accent = colors
+            .filter(|colors| colors.has_accent())
+            .map(|colors| colors.accent_color())
+            .unwrap_or_else(|| {
+                if state.pressed {
+                    theme.colors.accent_pressed
+                } else if state.hovered {
+                    theme.colors.accent_hovered
+                } else {
+                    theme.colors.accent
+                }
+            });
+        let mut background = colors
+            .filter(|colors| colors.has_background())
+            .map(|colors| colors.background_color())
+            .unwrap_or(theme.colors.surface);
+        let mut border_color = colors
+            .filter(|colors| colors.has_border())
+            .map(|colors| colors.border_color())
+            .unwrap_or(theme.colors.border);
+        let mut mark_visible = false;
+        let mut mark_color = theme.colors.text_primary;
+        if state.checked_state == SemanticCheckedState::True
+            || state.checked_state == SemanticCheckedState::Mixed
+        {
+            background = accent;
+            border_color = background;
+            mark_visible = state.checked_state == SemanticCheckedState::True;
+            mark_color = theme.colors.text_on_accent;
+        } else if state.hovered && colors.is_none_or(|colors| !colors.has_background()) {
+            background = theme.colors.background;
+        }
+        self.root
+            .corner_radius(metrics.corner_radius)
+            .border(1.0, border_color)
+            .bg_color(background);
+        if mark_visible {
+            self.mark_node.source(CHECKBOX_CHECK_SVG_URL);
+        } else {
+            self.mark_node.clear_source();
+        }
+        self.mark_node
+            .width(metrics.check_mark_size, Unit::Pixel)
+            .height(metrics.check_mark_size, Unit::Pixel)
+            .opacity(if mark_visible { 1.0 } else { 0.0 })
+            .tint(mark_color);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultCheckboxIndicatorTemplate;
+
+impl CheckboxIndicatorTemplate for DefaultCheckboxIndicatorTemplate {
+    fn create(&self, sizing: Option<LabeledControlSizing>) -> Rc<dyn CheckboxIndicatorPresenter> {
+        create_default_checkbox_indicator_presenter(sizing)
+    }
+}
+
+pub const DEFAULT_CHECKBOX_INDICATOR_TEMPLATE: DefaultCheckboxIndicatorTemplate =
+    DefaultCheckboxIndicatorTemplate;
+
+pub fn create_default_checkbox_indicator_presenter(
+    sizing: Option<LabeledControlSizing>,
+) -> Rc<dyn CheckboxIndicatorPresenter> {
+    Rc::new(DefaultCheckboxIndicatorPresenter::new(
+        resolve_checkbox_metrics(sizing),
+    ))
+}

package/src/controls/internal/dropdown_chevron_presenter.rs

@@ -0,0 +1,134 @@
+use crate::controls::DropdownSizing;
+use crate::ffi::{AlignItems, JustifyContent, Unit};
+use crate::node::{flex_box, svg, FlexBox, SvgNode};
+use crate::theme::Theme;
+use std::rc::Rc;
+
+const DROPDOWN_CHEVRON_COLLAPSED_SVG: &str = "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'><path d='M3 4.5 6 7.5 9 4.5' fill='none' stroke='%23000000' stroke-width='1.6' stroke-linecap='round' stroke-linejoin='round'/></svg>";
+const DROPDOWN_CHEVRON_EXPANDED_SVG: &str = "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'><path d='M3 7.5 6 4.5 9 7.5' fill='none' stroke='%23000000' stroke-width='1.6' stroke-linecap='round' stroke-linejoin='round'/></svg>";
+const DEFAULT_DROPDOWN_CHEVRON_ICON_SIZE: f32 = 12.0;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct DropdownChevronMetrics {
+    pub icon_size: f32,
+}
+
+impl DropdownChevronMetrics {
+    pub const fn new(icon_size: f32) -> Self {
+        Self { icon_size }
+    }
+}
+
+pub const DEFAULT_DROPDOWN_CHEVRON_METRICS: DropdownChevronMetrics =
+    DropdownChevronMetrics::new(DEFAULT_DROPDOWN_CHEVRON_ICON_SIZE);
+
+fn resolve_chevron_metrics(sizing: Option<DropdownSizing>) -> DropdownChevronMetrics {
+    let Some(sizing) = sizing else {
+        return DEFAULT_DROPDOWN_CHEVRON_METRICS;
+    };
+    if !sizing.has_chevron_icon_size() {
+        return DEFAULT_DROPDOWN_CHEVRON_METRICS;
+    }
+    DropdownChevronMetrics::new(sizing.chevron_icon_size_px())
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct DropdownChevronVisualState {
+    pub open: bool,
+    pub hovered: bool,
+    pub enabled: bool,
+}
+
+impl DropdownChevronVisualState {
+    pub const fn new(open: bool, hovered: bool, enabled: bool) -> Self {
+        Self {
+            open,
+            hovered,
+            enabled,
+        }
+    }
+}
+
+pub trait DropdownChevronPresenter {
+    fn root(&self) -> FlexBox;
+    fn apply(&self, theme: Theme, state: DropdownChevronVisualState);
+}
+
+pub trait DropdownChevronTemplate {
+    fn create(&self, sizing: Option<DropdownSizing>) -> Rc<dyn DropdownChevronPresenter>;
+}
+
+#[derive(Clone)]
+pub struct DefaultDropdownChevronPresenter {
+    root: FlexBox,
+    metrics: DropdownChevronMetrics,
+    icon_node: SvgNode,
+}
+
+impl DefaultDropdownChevronPresenter {
+    pub fn new(metrics: DropdownChevronMetrics) -> Self {
+        let root = flex_box();
+        root.fill_size()
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+        let icon_node = svg(0);
+        icon_node
+            .width(metrics.icon_size, Unit::Pixel)
+            .height(metrics.icon_size, Unit::Pixel);
+        root.child(&icon_node);
+        Self {
+            root,
+            metrics,
+            icon_node: icon_node.clone(),
+        }
+    }
+}
+
+impl DropdownChevronPresenter for DefaultDropdownChevronPresenter {
+    fn root(&self) -> FlexBox {
+        self.root.clone()
+    }
+
+    fn apply(&self, theme: Theme, state: DropdownChevronVisualState) {
+        let metrics = self.metrics;
+        self.root
+            .fill_size()
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+        self.icon_node
+            .width(metrics.icon_size, Unit::Pixel)
+            .height(metrics.icon_size, Unit::Pixel)
+            .source(if state.open {
+                DROPDOWN_CHEVRON_EXPANDED_SVG
+            } else {
+                DROPDOWN_CHEVRON_COLLAPSED_SVG
+            })
+            .tint(if !state.enabled {
+                theme.colors.text_muted
+            } else if state.hovered {
+                theme.colors.text_primary
+            } else {
+                theme.colors.text_muted
+            });
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultDropdownChevronTemplate;
+
+impl DropdownChevronTemplate for DefaultDropdownChevronTemplate {
+    fn create(&self, sizing: Option<DropdownSizing>) -> Rc<dyn DropdownChevronPresenter> {
+        create_default_dropdown_chevron_presenter(sizing)
+    }
+}
+
+pub const DEFAULT_DROPDOWN_CHEVRON_TEMPLATE: DefaultDropdownChevronTemplate =
+    DefaultDropdownChevronTemplate;
+
+pub fn create_default_dropdown_chevron_presenter(
+    sizing: Option<DropdownSizing>,
+) -> Rc<dyn DropdownChevronPresenter> {
+    Rc::new(DefaultDropdownChevronPresenter::new(
+        resolve_chevron_metrics(sizing),
+    ))
+}