@effindomv2/fui-rs 0.1.3

package/src/controls/internal/slider_presenter.rs

@@ -0,0 +1,282 @@
+use crate::controls::{SliderColors, SliderSizing};
+use crate::ffi::{Orientation, PositionType, Unit};
+use crate::node::{flex_box, FlexBox};
+use crate::theme::Theme;
+use std::rc::Rc;
+
+fn clamp(value: f32, min: f32, max: f32) -> f32 {
+    if value < min {
+        return min;
+    }
+    if value > max {
+        return max;
+    }
+    value
+}
+
+fn resolve_thumb_size(metrics: SliderPresenterMetrics) -> f32 {
+    if metrics.thumb_size > 1.0 {
+        metrics.thumb_size
+    } else {
+        1.0
+    }
+}
+
+fn resolve_track_thickness(metrics: SliderPresenterMetrics) -> f32 {
+    clamp(metrics.track_thickness, 1.0, resolve_thumb_size(metrics))
+}
+
+fn resolve_cross_axis_extra(metrics: SliderPresenterMetrics) -> f32 {
+    if metrics.cross_axis_extra > 0.0 {
+        metrics.cross_axis_extra
+    } else {
+        0.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SliderPresenterMetrics {
+    pub thumb_size: f32,
+    pub track_thickness: f32,
+    pub cross_axis_extra: f32,
+}
+
+impl SliderPresenterMetrics {
+    pub const fn new(thumb_size: f32, track_thickness: f32) -> Self {
+        Self {
+            thumb_size,
+            track_thickness,
+            cross_axis_extra: 2.0,
+        }
+    }
+
+    pub const fn with_cross_axis_extra(mut self, cross_axis_extra: f32) -> Self {
+        self.cross_axis_extra = cross_axis_extra;
+        self
+    }
+
+    pub const fn with_values(thumb_size: f32, track_thickness: f32, cross_axis_extra: f32) -> Self {
+        Self {
+            thumb_size,
+            track_thickness,
+            cross_axis_extra,
+        }
+    }
+}
+
+const DEFAULT_SLIDER_METRICS: SliderPresenterMetrics = SliderPresenterMetrics::new(18.0, 6.0);
+
+fn resolve_slider_metrics(sizing: Option<SliderSizing>) -> SliderPresenterMetrics {
+    let Some(sizing) = sizing else {
+        return DEFAULT_SLIDER_METRICS;
+    };
+    let thumb_size = if sizing.has_thumb_size() {
+        sizing.thumb_size_px()
+    } else {
+        DEFAULT_SLIDER_METRICS.thumb_size
+    };
+    let track_thickness = if sizing.has_track_thickness() {
+        sizing.track_thickness_px()
+    } else {
+        DEFAULT_SLIDER_METRICS.track_thickness
+    };
+    if (thumb_size - DEFAULT_SLIDER_METRICS.thumb_size).abs() <= f32::EPSILON
+        && (track_thickness - DEFAULT_SLIDER_METRICS.track_thickness).abs() <= f32::EPSILON
+    {
+        return DEFAULT_SLIDER_METRICS;
+    }
+    SliderPresenterMetrics::new(thumb_size, track_thickness)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SliderVisualState {
+    pub value: f32,
+    pub min: f32,
+    pub max: f32,
+    pub normalized_value: f32,
+    pub orientation: Orientation,
+    pub hovered: bool,
+    pub dragging: bool,
+    pub focused: bool,
+    pub enabled: bool,
+}
+
+impl SliderVisualState {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        value: f32,
+        min: f32,
+        max: f32,
+        normalized_value: f32,
+        orientation: Orientation,
+        hovered: bool,
+        dragging: bool,
+        focused: bool,
+        enabled: bool,
+    ) -> Self {
+        Self {
+            value,
+            min,
+            max,
+            normalized_value,
+            orientation,
+            hovered,
+            dragging,
+            focused,
+            enabled,
+        }
+    }
+}
+
+pub trait SliderPresenter {
+    fn root(&self) -> FlexBox;
+    fn metrics(&self) -> SliderPresenterMetrics;
+    fn layout(&self, state: SliderVisualState, length: f32);
+    fn apply(&self, theme: Theme, state: SliderVisualState, colors: Option<SliderColors>);
+}
+
+pub trait SliderTemplate {
+    fn create(&self, sizing: Option<SliderSizing>) -> Rc<dyn SliderPresenter>;
+}
+
+#[derive(Clone)]
+pub struct DefaultSliderPresenter {
+    root: FlexBox,
+    metrics: SliderPresenterMetrics,
+    track_node: FlexBox,
+    fill_node: FlexBox,
+    thumb_node: FlexBox,
+}
+
+impl DefaultSliderPresenter {
+    pub fn new(metrics: SliderPresenterMetrics) -> Self {
+        let root = flex_box();
+        let track_node = flex_box();
+        track_node.position_type(PositionType::Absolute);
+        let fill_node = flex_box();
+        fill_node.position_type(PositionType::Absolute);
+        let thumb_node = flex_box();
+        thumb_node
+            .position_type(PositionType::Absolute)
+            .width(metrics.thumb_size, Unit::Pixel)
+            .height(metrics.thumb_size, Unit::Pixel);
+        root.child(&track_node).child(&fill_node).child(&thumb_node);
+        Self {
+            root,
+            metrics,
+            track_node,
+            fill_node,
+            thumb_node,
+        }
+    }
+}
+
+impl SliderPresenter for DefaultSliderPresenter {
+    fn root(&self) -> FlexBox {
+        self.root.clone()
+    }
+
+    fn metrics(&self) -> SliderPresenterMetrics {
+        self.metrics
+    }
+
+    fn layout(&self, state: SliderVisualState, length: f32) {
+        let metrics = self.metrics;
+        let thumb_size = resolve_thumb_size(metrics);
+        let track_thickness = resolve_track_thickness(metrics);
+        let cross_axis_extra = resolve_cross_axis_extra(metrics);
+        let available = if length > thumb_size {
+            length - thumb_size
+        } else {
+            0.0
+        };
+        let fraction = clamp(state.normalized_value, 0.0, 1.0);
+        let cross_axis_inset = cross_axis_extra * 0.5;
+        let track_offset = cross_axis_inset + ((thumb_size - track_thickness) * 0.5);
+        if state.orientation == Orientation::Vertical {
+            self.root
+                .width(thumb_size + cross_axis_extra, Unit::Pixel)
+                .height(length, Unit::Pixel);
+            self.track_node
+                .width(track_thickness, Unit::Pixel)
+                .height(available, Unit::Pixel)
+                .position(track_offset, thumb_size * 0.5);
+            self.fill_node
+                .width(track_thickness, Unit::Pixel)
+                .height(available * fraction, Unit::Pixel)
+                .position(
+                    track_offset,
+                    thumb_size * 0.5 + (available * (1.0 - fraction)),
+                );
+            self.thumb_node
+                .position(cross_axis_inset, available - (available * fraction));
+            return;
+        }
+
+        self.root
+            .width(length, Unit::Pixel)
+            .height(thumb_size + cross_axis_extra, Unit::Pixel);
+        self.track_node
+            .width(available, Unit::Pixel)
+            .height(track_thickness, Unit::Pixel)
+            .position(thumb_size * 0.5, track_offset);
+        self.fill_node
+            .width(available * fraction, Unit::Pixel)
+            .height(track_thickness, Unit::Pixel)
+            .position(thumb_size * 0.5, track_offset);
+        self.thumb_node
+            .position(available * fraction, cross_axis_inset);
+    }
+
+    fn apply(&self, theme: Theme, state: SliderVisualState, colors: Option<SliderColors>) {
+        let accent = if state.dragging {
+            theme.colors.accent_pressed
+        } else if state.hovered {
+            theme.colors.accent_hovered
+        } else {
+            theme.colors.accent
+        };
+        let metrics = self.metrics;
+        let thumb_size = resolve_thumb_size(metrics);
+        let track_thickness = resolve_track_thickness(metrics);
+        let track_radius = track_thickness * 0.5;
+        self.track_node.corner_radius(track_radius);
+        let track_color = colors
+            .filter(|colors| colors.has_track())
+            .map(|colors| colors.track_color())
+            .unwrap_or(theme.colors.scrollbar_track);
+        self.track_node.bg_color(track_color);
+        self.fill_node.corner_radius(track_radius);
+        let fill_color = colors
+            .filter(|colors| colors.has_fill())
+            .map(|colors| colors.fill_color())
+            .unwrap_or(accent);
+        self.fill_node.bg_color(fill_color);
+        self.thumb_node
+            .width(thumb_size, Unit::Pixel)
+            .height(thumb_size, Unit::Pixel)
+            .corner_radius(thumb_size * 0.5);
+        let thumb_color = colors
+            .filter(|colors| colors.has_thumb())
+            .map(|colors| colors.thumb_color())
+            .unwrap_or(accent);
+        self.thumb_node
+            .bg_color(thumb_color)
+            .border(1.0, theme.colors.surface);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultSliderTemplate;
+
+impl SliderTemplate for DefaultSliderTemplate {
+    fn create(&self, sizing: Option<SliderSizing>) -> Rc<dyn SliderPresenter> {
+        create_default_slider_presenter(sizing)
+    }
+}
+
+pub const DEFAULT_SLIDER_TEMPLATE: DefaultSliderTemplate = DefaultSliderTemplate;
+
+pub fn create_default_slider_presenter(sizing: Option<SliderSizing>) -> Rc<dyn SliderPresenter> {
+    Rc::new(DefaultSliderPresenter::new(resolve_slider_metrics(sizing)))
+}

package/src/controls/internal/switch_indicator_presenter.rs

@@ -0,0 +1,235 @@
+use super::pressable_indicator_presenter::{
+    PressableIndicatorMetrics, PressableIndicatorPresenter, PressableIndicatorVisualState,
+};
+use crate::controls::{LabeledControlColors, LabeledControlSizing};
+use crate::ffi::{AlignItems, PositionType, Unit};
+use crate::node::{flex_box, FlexBox};
+use crate::theme::Theme;
+use std::rc::Rc;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SwitchIndicatorVisualState {
+    pub checked: bool,
+    pub hovered: bool,
+    pub pressed: bool,
+    pub focused: bool,
+    pub enabled: bool,
+}
+
+impl SwitchIndicatorVisualState {
+    pub fn new(checked: bool, hovered: bool, pressed: bool, focused: bool, enabled: bool) -> Self {
+        Self {
+            checked,
+            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 SwitchIndicatorPresenter: PressableIndicatorPresenter {
+    fn apply(
+        &self,
+        theme: Theme,
+        state: SwitchIndicatorVisualState,
+        colors: Option<LabeledControlColors>,
+    );
+}
+
+pub trait SwitchIndicatorTemplate {
+    fn create(&self, sizing: Option<LabeledControlSizing>) -> Rc<dyn SwitchIndicatorPresenter>;
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SwitchIndicatorMetrics {
+    pub track_width: f32,
+    pub track_height: f32,
+    pub thumb_size: f32,
+    pub thumb_x: f32,
+    pub thumb_checked_x: f32,
+    pub thumb_y: f32,
+}
+
+impl SwitchIndicatorMetrics {
+    pub const fn new(
+        track_width: f32,
+        track_height: f32,
+        thumb_size: f32,
+        thumb_x: f32,
+        thumb_checked_x: f32,
+        thumb_y: f32,
+    ) -> Self {
+        Self {
+            track_width,
+            track_height,
+            thumb_size,
+            thumb_x,
+            thumb_checked_x,
+            thumb_y,
+        }
+    }
+}
+
+const DEFAULT_SWITCH_METRICS: SwitchIndicatorMetrics =
+    SwitchIndicatorMetrics::new(44.0, 26.0, 20.0, 3.0, 21.0, 2.0);
+
+pub fn resolve_switch_metrics(sizing: Option<LabeledControlSizing>) -> SwitchIndicatorMetrics {
+    let Some(sizing) = sizing else {
+        return DEFAULT_SWITCH_METRICS;
+    };
+    if !sizing.has_indicator_size() {
+        return DEFAULT_SWITCH_METRICS;
+    }
+    let scale = sizing.indicator_size_px() / DEFAULT_SWITCH_METRICS.track_height;
+    let track_width = DEFAULT_SWITCH_METRICS.track_width * scale;
+    let track_height = DEFAULT_SWITCH_METRICS.track_height * scale;
+    let thumb_size = DEFAULT_SWITCH_METRICS.thumb_size * scale;
+    let thumb_x = DEFAULT_SWITCH_METRICS.thumb_x * scale;
+    let thumb_y = DEFAULT_SWITCH_METRICS.thumb_y * scale;
+    SwitchIndicatorMetrics::new(
+        track_width,
+        track_height,
+        thumb_size,
+        thumb_x,
+        track_width - thumb_size - thumb_x,
+        thumb_y,
+    )
+}
+
+#[derive(Clone)]
+pub struct DefaultSwitchIndicatorPresenter {
+    root: FlexBox,
+    metrics: SwitchIndicatorMetrics,
+    thumb_node: FlexBox,
+}
+
+impl DefaultSwitchIndicatorPresenter {
+    pub fn new(metrics: SwitchIndicatorMetrics) -> Self {
+        let root = flex_box();
+        root.width(metrics.track_width, Unit::Pixel)
+            .height(metrics.track_height, Unit::Pixel)
+            .clip_to_bounds(true);
+        let thumb_node = flex_box();
+        thumb_node
+            .position_type(PositionType::Absolute)
+            .position(metrics.thumb_x, metrics.thumb_y)
+            .width(metrics.thumb_size, Unit::Pixel)
+            .height(metrics.thumb_size, Unit::Pixel);
+        root.align_items(AlignItems::Center).child(&thumb_node);
+        Self {
+            root,
+            metrics,
+            thumb_node,
+        }
+    }
+}
+
+impl PressableIndicatorPresenter for DefaultSwitchIndicatorPresenter {
+    fn root(&self) -> FlexBox {
+        self.root.clone()
+    }
+
+    fn metrics(&self) -> PressableIndicatorMetrics {
+        PressableIndicatorMetrics::new(self.metrics.track_width, self.metrics.track_height)
+    }
+}
+
+impl SwitchIndicatorPresenter for DefaultSwitchIndicatorPresenter {
+    fn apply(
+        &self,
+        theme: Theme,
+        state: SwitchIndicatorVisualState,
+        colors: Option<LabeledControlColors>,
+    ) {
+        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 track_color = if state.checked {
+            accent
+        } else {
+            colors
+                .filter(|colors| colors.has_background())
+                .map(|colors| colors.background_color())
+                .unwrap_or_else(|| {
+                    if state.hovered {
+                        theme.colors.background
+                    } else {
+                        theme.colors.surface
+                    }
+                })
+        };
+        let border_color = colors
+            .filter(|colors| colors.has_border())
+            .map(|colors| colors.border_color())
+            .unwrap_or_else(|| {
+                if state.checked {
+                    track_color
+                } else {
+                    theme.colors.border
+                }
+            });
+        let metrics = self.metrics;
+        self.root
+            .corner_radius(metrics.track_height * 0.5)
+            .border(1.0, border_color)
+            .bg_color(track_color);
+        self.thumb_node
+            .position(
+                if state.checked {
+                    metrics.thumb_checked_x
+                } else {
+                    metrics.thumb_x
+                },
+                metrics.thumb_y,
+            )
+            .width(metrics.thumb_size, Unit::Pixel)
+            .height(metrics.thumb_size, Unit::Pixel)
+            .corner_radius(metrics.thumb_size * 0.5)
+            .bg_color(
+                colors
+                    .filter(|colors| colors.has_background())
+                    .map(|colors| colors.background_color())
+                    .unwrap_or(theme.colors.surface),
+            )
+            .border(1.0, border_color);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct DefaultSwitchIndicatorTemplate;
+
+impl SwitchIndicatorTemplate for DefaultSwitchIndicatorTemplate {
+    fn create(&self, sizing: Option<LabeledControlSizing>) -> Rc<dyn SwitchIndicatorPresenter> {
+        create_default_switch_indicator_presenter(sizing)
+    }
+}
+
+pub const DEFAULT_SWITCH_INDICATOR_TEMPLATE: DefaultSwitchIndicatorTemplate =
+    DefaultSwitchIndicatorTemplate;
+
+pub fn create_default_switch_indicator_presenter(
+    sizing: Option<LabeledControlSizing>,
+) -> Rc<dyn SwitchIndicatorPresenter> {
+    Rc::new(DefaultSwitchIndicatorPresenter::new(
+        resolve_switch_metrics(sizing),
+    ))
+}