@effindomv2/fui-rs 0.1.3

package/src/controls/internal/dropdown_field_presenter.rs

@@ -0,0 +1,269 @@
+use crate::controls::{DropdownColors, DropdownSizing};
+use crate::ffi::{AlignItems, FlexDirection, JustifyContent, TextVerticalAlign, Unit};
+use crate::node::{flex_box, text, FlexBox, TextNode};
+use crate::theme::Theme;
+use std::rc::Rc;
+
+const DEFAULT_CHEVRON_BOX_SIZE: f32 = 16.0;
+const DEFAULT_FIELD_PADDING_X: f32 = 16.0;
+const DEFAULT_FIELD_FONT_SIZE: f32 = 16.0;
+const DEFAULT_FIELD_HEIGHT: f32 = 32.0;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct DropdownFieldMetrics {
+    pub height: f32,
+    pub font_size: f32,
+    pub chevron_box_size: f32,
+    pub padding_left: f32,
+    pub padding_top: f32,
+    pub padding_right: f32,
+    pub padding_bottom: f32,
+}
+
+impl DropdownFieldMetrics {
+    pub const fn new(
+        height: f32,
+        font_size: f32,
+        chevron_box_size: f32,
+        padding_left: f32,
+        padding_top: f32,
+        padding_right: f32,
+        padding_bottom: f32,
+    ) -> Self {
+        Self {
+            height,
+            font_size,
+            chevron_box_size,
+            padding_left,
+            padding_top,
+            padding_right,
+            padding_bottom,
+        }
+    }
+}
+
+pub const DEFAULT_DROPDOWN_FIELD_METRICS: DropdownFieldMetrics = DropdownFieldMetrics::new(
+    DEFAULT_FIELD_HEIGHT,
+    DEFAULT_FIELD_FONT_SIZE,
+    DEFAULT_CHEVRON_BOX_SIZE,
+    DEFAULT_FIELD_PADDING_X,
+    0.0,
+    DEFAULT_FIELD_PADDING_X,
+    0.0,
+);
+
+fn resolve_field_metrics(sizing: Option<DropdownSizing>) -> DropdownFieldMetrics {
+    let Some(sizing) = sizing else {
+        return DEFAULT_DROPDOWN_FIELD_METRICS;
+    };
+    if !sizing.has_field_height() && !sizing.has_field_font_size() && !sizing.has_chevron_box_size()
+    {
+        return DEFAULT_DROPDOWN_FIELD_METRICS;
+    }
+    let font_size = if sizing.has_field_font_size() {
+        sizing.field_font_size_px()
+    } else {
+        DEFAULT_DROPDOWN_FIELD_METRICS.font_size
+    };
+    let chevron_box_size = if sizing.has_chevron_box_size() {
+        sizing.chevron_box_size_px()
+    } else {
+        DEFAULT_DROPDOWN_FIELD_METRICS.chevron_box_size
+    };
+    let content_height = font_size.max(chevron_box_size);
+    let height = if sizing.has_field_height() {
+        sizing.field_height_px()
+    } else {
+        DEFAULT_DROPDOWN_FIELD_METRICS.height.max(content_height)
+    };
+    DropdownFieldMetrics::new(
+        height,
+        font_size,
+        chevron_box_size,
+        DEFAULT_FIELD_PADDING_X,
+        0.0,
+        DEFAULT_FIELD_PADDING_X,
+        0.0,
+    )
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DropdownFieldVisualState {
+    pub open: bool,
+    pub focused: bool,
+    pub enabled: bool,
+    pub pressed: bool,
+    pub selected_label: String,
+}
+
+impl DropdownFieldVisualState {
+    pub fn new(
+        open: bool,
+        focused: bool,
+        enabled: bool,
+        pressed: bool,
+        selected_label: impl Into<String>,
+    ) -> Self {
+        Self {
+            open,
+            focused,
+            enabled,
+            pressed,
+            selected_label: selected_label.into(),
+        }
+    }
+}
+
+pub trait DropdownFieldPresenter {
+    fn root(&self) -> FlexBox;
+    fn value_host(&self) -> FlexBox;
+    fn value_node(&self) -> TextNode;
+    fn chevron_host(&self) -> FlexBox;
+    fn metrics(&self) -> DropdownFieldMetrics;
+    fn apply(&self, theme: Theme, state: &DropdownFieldVisualState, colors: Option<DropdownColors>);
+}
+
+pub trait DropdownFieldTemplate {
+    fn create(&self, sizing: Option<DropdownSizing>) -> Rc<dyn DropdownFieldPresenter>;
+}
+
+#[derive(Clone)]
+pub struct DefaultDropdownFieldPresenter {
+    root: FlexBox,
+    value_host: FlexBox,
+    value_node: TextNode,
+    chevron_host: FlexBox,
+    metrics: DropdownFieldMetrics,
+}
+
+impl DefaultDropdownFieldPresenter {
+    pub fn new(metrics: DropdownFieldMetrics) -> Self {
+        let theme = crate::theme::current_theme();
+        let value_node = text("");
+        value_node
+            .selectable(false, theme.colors.selection)
+            .fill_size()
+            .text_limits(0, 1)
+            .wrapping(false);
+        value_node
+            .text_overflow_fade(true, false)
+            .text_vertical_align(TextVerticalAlign::Center);
+        let value_host = flex_box();
+        value_host.fill_size().child(&value_node);
+        let chevron_host = flex_box();
+        chevron_host
+            .width(metrics.chevron_box_size, Unit::Pixel)
+            .height(metrics.chevron_box_size, Unit::Pixel)
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+        let root = flex_box();
+        root.flex_direction(FlexDirection::Row)
+            .align_items(AlignItems::Center)
+            .child(&value_host)
+            .child(&chevron_host);
+        Self {
+            root,
+            value_host,
+            value_node: value_node.clone(),
+            chevron_host,
+            metrics,
+        }
+    }
+}
+
+impl DropdownFieldPresenter for DefaultDropdownFieldPresenter {
+    fn root(&self) -> FlexBox {
+        self.root.clone()
+    }
+
+    fn value_host(&self) -> FlexBox {
+        self.value_host.clone()
+    }
+
+    fn value_node(&self) -> TextNode {
+        self.value_node.clone()
+    }
+
+    fn chevron_host(&self) -> FlexBox {
+        self.chevron_host.clone()
+    }
+
+    fn metrics(&self) -> DropdownFieldMetrics {
+        self.metrics
+    }
+
+    fn apply(
+        &self,
+        theme: Theme,
+        state: &DropdownFieldVisualState,
+        colors: Option<DropdownColors>,
+    ) {
+        let metrics = self.metrics;
+        let content_height = metrics
+            .font_size
+            .max(metrics.height - metrics.padding_top - metrics.padding_bottom);
+        let bg = if colors.is_some_and(|colors| colors.has_background()) {
+            colors.unwrap().background_color()
+        } else if state.pressed && state.enabled {
+            theme.colors.background
+        } else {
+            theme.colors.surface
+        };
+        let border_color = colors
+            .filter(|colors| colors.has_border())
+            .map(|colors| colors.border_color())
+            .unwrap_or(theme.colors.border);
+        self.root
+            .flex_direction(FlexDirection::Row)
+            .align_items(AlignItems::Center)
+            .height(metrics.height, Unit::Pixel)
+            .corner_radius(theme.spacing.sm)
+            .border(2.0, border_color)
+            .padding(
+                metrics.padding_left,
+                metrics.padding_top,
+                metrics.padding_right,
+                metrics.padding_bottom,
+            )
+            .bg_color(bg);
+        self.value_host.fill_size();
+        let text_color = if !state.enabled {
+            theme.colors.text_muted
+        } else {
+            colors
+                .filter(|colors| colors.has_text_primary())
+                .map(|colors| colors.text_primary_color())
+                .unwrap_or(theme.colors.text_primary)
+        };
+        self.value_node
+            .font_family(theme.fonts.body_family.clone())
+            .font_size(metrics.font_size)
+            .line_height(content_height)
+            .text_color(text_color);
+        self.chevron_host
+            .width(metrics.chevron_box_size, Unit::Pixel)
+            .height(metrics.chevron_box_size, Unit::Pixel)
+            .align_items(AlignItems::Center)
+            .justify_content(JustifyContent::Center);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultDropdownFieldTemplate;
+
+impl DropdownFieldTemplate for DefaultDropdownFieldTemplate {
+    fn create(&self, sizing: Option<DropdownSizing>) -> Rc<dyn DropdownFieldPresenter> {
+        create_default_dropdown_field_presenter(sizing)
+    }
+}
+
+pub const DEFAULT_DROPDOWN_FIELD_TEMPLATE: DefaultDropdownFieldTemplate =
+    DefaultDropdownFieldTemplate;
+
+pub fn create_default_dropdown_field_presenter(
+    sizing: Option<DropdownSizing>,
+) -> Rc<dyn DropdownFieldPresenter> {
+    Rc::new(DefaultDropdownFieldPresenter::new(resolve_field_metrics(
+        sizing,
+    )))
+}

package/src/controls/internal/dropdown_option_row_presenter.rs

@@ -0,0 +1,184 @@
+use crate::controls::{DropdownColors, DropdownSizing};
+use crate::ffi::{AlignItems, TextVerticalAlign};
+use crate::node::{flex_box, text, FlexBox, TextNode};
+use crate::theme::Theme;
+use std::rc::Rc;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct DropdownOptionRowMetrics {
+    pub height: f32,
+    pub padding_left: f32,
+    pub padding_right: f32,
+    pub font_size: f32,
+}
+
+impl DropdownOptionRowMetrics {
+    pub const fn new(height: f32, padding_left: f32, padding_right: f32, font_size: f32) -> Self {
+        Self {
+            height,
+            padding_left,
+            padding_right,
+            font_size,
+        }
+    }
+}
+
+pub const DEFAULT_DROPDOWN_OPTION_ROW_METRICS: DropdownOptionRowMetrics =
+    DropdownOptionRowMetrics::new(34.0, 10.0, 10.0, 16.0);
+
+fn resolve_option_row_metrics(sizing: Option<DropdownSizing>) -> DropdownOptionRowMetrics {
+    let Some(sizing) = sizing else {
+        return DEFAULT_DROPDOWN_OPTION_ROW_METRICS;
+    };
+    if !sizing.has_option_height() && !sizing.has_option_font_size() {
+        return DEFAULT_DROPDOWN_OPTION_ROW_METRICS;
+    }
+    let font_size = if sizing.has_option_font_size() {
+        sizing.option_font_size_px()
+    } else {
+        DEFAULT_DROPDOWN_OPTION_ROW_METRICS.font_size
+    };
+    let height = if sizing.has_option_height() {
+        sizing.option_height_px()
+    } else {
+        DEFAULT_DROPDOWN_OPTION_ROW_METRICS.height
+    };
+    DropdownOptionRowMetrics::new(
+        height,
+        DEFAULT_DROPDOWN_OPTION_ROW_METRICS.padding_left,
+        DEFAULT_DROPDOWN_OPTION_ROW_METRICS.padding_right,
+        font_size,
+    )
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct DropdownOptionRowVisualState {
+    pub highlighted: bool,
+    pub selected: bool,
+    pub enabled: bool,
+}
+
+impl DropdownOptionRowVisualState {
+    pub const fn new(highlighted: bool, selected: bool, enabled: bool) -> Self {
+        Self {
+            highlighted,
+            selected,
+            enabled,
+        }
+    }
+}
+
+pub trait DropdownOptionRowPresenter {
+    fn root(&self) -> FlexBox;
+    fn label_node(&self) -> TextNode;
+    fn metrics(&self) -> DropdownOptionRowMetrics;
+    fn apply(
+        &self,
+        theme: Theme,
+        state: DropdownOptionRowVisualState,
+        colors: Option<DropdownColors>,
+    );
+}
+
+pub trait DropdownOptionRowTemplate {
+    fn create(&self, sizing: Option<DropdownSizing>) -> Rc<dyn DropdownOptionRowPresenter>;
+}
+
+#[derive(Clone)]
+pub struct DefaultDropdownOptionRowPresenter {
+    root: FlexBox,
+    label_node: TextNode,
+    metrics: DropdownOptionRowMetrics,
+}
+
+impl DefaultDropdownOptionRowPresenter {
+    pub fn new(metrics: DropdownOptionRowMetrics) -> Self {
+        let theme = crate::theme::current_theme();
+        let label_node = text("");
+        label_node
+            .selectable(false, theme.colors.selection)
+            .fill_size()
+            .text_limits(0, 1)
+            .wrapping(false);
+        label_node
+            .text_overflow_fade(true, false)
+            .text_vertical_align(TextVerticalAlign::Center);
+        let root = flex_box();
+        root.fill_size()
+            .align_items(AlignItems::Center)
+            .child(&label_node);
+        Self {
+            root,
+            label_node: label_node.clone(),
+            metrics,
+        }
+    }
+}
+
+impl DropdownOptionRowPresenter for DefaultDropdownOptionRowPresenter {
+    fn root(&self) -> FlexBox {
+        self.root.clone()
+    }
+
+    fn label_node(&self) -> TextNode {
+        self.label_node.clone()
+    }
+
+    fn metrics(&self) -> DropdownOptionRowMetrics {
+        self.metrics
+    }
+
+    fn apply(
+        &self,
+        theme: Theme,
+        state: DropdownOptionRowVisualState,
+        colors: Option<DropdownColors>,
+    ) {
+        let metrics = self.metrics;
+        self.root
+            .padding(metrics.padding_left, 0.0, metrics.padding_right, 0.0)
+            .corner_radius(theme.spacing.xs)
+            .bg_color(if state.highlighted {
+                theme.context_menu.item.hover_background
+            } else {
+                0x00000000
+            });
+        let label_color = if !state.enabled {
+            theme.colors.text_muted
+        } else if state.selected {
+            colors
+                .filter(|colors| colors.has_accent())
+                .map(|colors| colors.accent_color())
+                .unwrap_or(theme.colors.accent)
+        } else {
+            colors
+                .filter(|colors| colors.has_text_primary())
+                .map(|colors| colors.text_primary_color())
+                .unwrap_or(theme.colors.text_primary)
+        };
+        self.label_node
+            .font_family(theme.fonts.body_family.clone())
+            .font_size(metrics.font_size)
+            .text_color(label_color);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultDropdownOptionRowTemplate;
+
+impl DropdownOptionRowTemplate for DefaultDropdownOptionRowTemplate {
+    fn create(&self, sizing: Option<DropdownSizing>) -> Rc<dyn DropdownOptionRowPresenter> {
+        create_default_dropdown_option_row_presenter(sizing)
+    }
+}
+
+pub const DEFAULT_DROPDOWN_OPTION_ROW_TEMPLATE: DefaultDropdownOptionRowTemplate =
+    DefaultDropdownOptionRowTemplate;
+
+pub fn create_default_dropdown_option_row_presenter(
+    sizing: Option<DropdownSizing>,
+) -> Rc<dyn DropdownOptionRowPresenter> {
+    Rc::new(DefaultDropdownOptionRowPresenter::new(
+        resolve_option_row_metrics(sizing),
+    ))
+}

package/src/controls/internal/mod.rs

@@ -0,0 +1,13 @@
+pub(crate) mod button_presenter;
+pub(crate) mod checkbox_indicator_presenter;
+pub(crate) mod dropdown_chevron_presenter;
+pub(crate) mod dropdown_field_presenter;
+pub(crate) mod dropdown_option_row_presenter;
+pub(crate) mod pressable_indicator_presenter;
+pub(crate) mod pressable_labeled_control;
+pub(crate) mod radio_indicator_presenter;
+pub(crate) mod selectable_popup_list;
+pub(crate) mod slider_presenter;
+pub(crate) mod switch_indicator_presenter;
+pub(crate) mod text_input_core;
+pub(crate) mod text_input_presenter;

package/src/controls/internal/pressable_indicator_presenter.rs

@@ -0,0 +1,26 @@
+use crate::node::FlexBox;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct PressableIndicatorMetrics {
+    pub width: f32,
+    pub height: f32,
+}
+
+impl PressableIndicatorMetrics {
+    pub const fn new(width: f32, height: f32) -> Self {
+        Self { width, height }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct PressableIndicatorVisualState {
+    pub hovered: bool,
+    pub pressed: bool,
+    pub focused: bool,
+    pub enabled: bool,
+}
+
+pub trait PressableIndicatorPresenter {
+    fn root(&self) -> FlexBox;
+    fn metrics(&self) -> PressableIndicatorMetrics;
+}