lgui-widgets 0.2.0

Theme tokens and reusable widgets for LGUI
Documentation
use std::{ops::RangeInclusive, sync::Arc};

use crate::core::{
    Color, Element, ElementKey, ElementRenderCx, RenderPhase, UiEventContext, UiRect,
};
use crate::theme::ThemeTokens;

use super::{
    math::{normalize_range, valid_step},
    render::render_slider,
};

pub type SliderChangeHandler = Arc<dyn Fn(&mut UiEventContext, f64) + Send + Sync>;
pub type SliderValueFormatter = Arc<dyn Fn(f64) -> String + Send + Sync>;
pub(super) const SLIDER_HOVER_IN_MS: f32 = 110.0;
pub(super) const SLIDER_HOVER_OUT_MS: f32 = 150.0;
pub(super) const SLIDER_VALUE_WIDTH: f32 = 48.0;
pub(super) const SLIDER_VALUE_GAP: f32 = 10.0;
pub(super) const CHANGE_EVENT: &str = "slider.change";
pub(super) const COMMIT_EVENT: &str = "slider.commit";

pub trait IntoSliderChangeHandler {
    fn into_slider_change_handler(self) -> SliderChangeHandler;
}

impl<F> IntoSliderChangeHandler for F
where
    F: Fn(f64) + Send + Sync + 'static,
{
    fn into_slider_change_handler(self) -> SliderChangeHandler {
        Arc::new(move |_context, value| self(value))
    }
}

impl IntoSliderChangeHandler for SliderChangeHandler {
    fn into_slider_change_handler(self) -> SliderChangeHandler {
        self
    }
}

#[derive(Clone, Copy)]
pub struct SliderStyle {
    pub track: Color,
    pub active_track: Color,
    pub thumb: Color,
    pub thumb_border: Color,
    pub value_text: Color,
    pub track_height: f32,
    pub thumb_size: f32,
    pub disabled_alpha: u8,
}

impl SliderStyle {
    pub fn from_theme(theme: &ThemeTokens) -> Self {
        Self {
            track: theme.colors.border,
            active_track: theme.colors.accent,
            thumb: theme.colors.accent,
            thumb_border: theme.colors.surface_raised,
            value_text: theme.colors.accent,
            track_height: 4.0,
            thumb_size: 14.0,
            disabled_alpha: 0x60,
        }
    }
}

impl Default for SliderStyle {
    fn default() -> Self {
        Self::from_theme(&ThemeTokens::default())
    }
}

pub struct Slider {
    pub(super) key: ElementKey,
    pub(super) rect: UiRect,
    pub(super) value: f64,
    pub(super) min: f64,
    pub(super) max: f64,
    pub(super) step: Option<f64>,
    pub(super) enabled: bool,
    pub(super) phase: RenderPhase,
    pub(super) style: Option<SliderStyle>,
    pub(super) value_formatter: Option<SliderValueFormatter>,
    pub(super) on_change: SliderChangeHandler,
    pub(super) on_commit: Option<SliderChangeHandler>,
}

impl Slider {
    pub fn step(mut self, step: f64) -> Self {
        self.step = valid_step(step);
        self
    }

    pub fn enabled(mut self, enabled: bool) -> Self {
        self.enabled = enabled;
        self
    }

    pub fn phase(mut self, phase: RenderPhase) -> Self {
        self.phase = phase;
        self
    }

    pub fn style(mut self, style: SliderStyle) -> Self {
        self.style = Some(style);
        self
    }

    pub fn format_value(
        mut self,
        formatter: impl Fn(f64) -> String + Send + Sync + 'static,
    ) -> Self {
        self.value_formatter = Some(Arc::new(formatter));
        self
    }

    pub fn on_commit(mut self, on_commit: impl IntoSliderChangeHandler) -> Self {
        self.on_commit = Some(on_commit.into_slider_change_handler());
        self
    }
}

impl From<Slider> for Element {
    fn from(value: Slider) -> Self {
        Element::with_key(value.key, move |cx: ElementRenderCx<'_, '_, '_>| {
            render_slider(cx, value)
        })
    }
}

#[track_caller]
pub fn slider(
    rect: UiRect,
    value: f64,
    range: RangeInclusive<f64>,
    on_change: impl IntoSliderChangeHandler,
) -> Slider {
    let (min, max) = normalize_range(*range.start(), *range.end());
    Slider {
        key: ElementKey::caller(),
        rect,
        value,
        min,
        max,
        step: None,
        enabled: true,
        phase: RenderPhase::Content,
        style: None,
        value_formatter: None,
        on_change: on_change.into_slider_change_handler(),
        on_commit: None,
    }
}