bevy_feathers 0.19.0

use core::f32::consts::PI;

use bevy_app::{Plugin, PreUpdate};
use bevy_asset::Handle;
use bevy_color::{Alpha, Color, Hsla};
use bevy_ecs::{
    bundle::Bundle,
    children,
    component::Component,
    entity::Entity,
    hierarchy::Children,
    query::{Changed, Or, With},
    reflect::ReflectComponent,
    schedule::IntoScheduleConfigs,
    system::Query,
};
use bevy_input_focus::tab_navigation::TabIndex;
use bevy_log::warn_once;
use bevy_picking::PickingSystems;
use bevy_reflect::std_traits::ReflectDefault;
use bevy_reflect::Reflect;
use bevy_scene::prelude::*;
use bevy_ui::{
    percent, px, AlignItems, BackgroundColor, BackgroundGradient, BorderColor, BorderRadius,
    ColorStop, Display, FlexDirection, Gradient, InterpolationColorSpace, LinearGradient, Node,
    Outline, PositionType, UiRect, UiTransform, Val2, ZIndex,
};
use bevy_ui_render::ui_material::MaterialNode;
use bevy_ui_widgets::{
    Slider, SliderOrientation, SliderRange, SliderThumb, SliderValue, TrackClick,
};

use crate::{
    alpha_pattern::{AlphaPattern, AlphaPatternMaterial},
    cursor::EntityCursor,
    focus::FocusIndicator,
    palette,
    rounded_corners::RoundedCorners,
};

const SLIDER_HEIGHT: f32 = 16.0;
const TRACK_PADDING: f32 = 3.0;
const TRACK_RADIUS: f32 = SLIDER_HEIGHT * 0.5 - TRACK_PADDING;
const THUMB_SIZE: f32 = SLIDER_HEIGHT - 2.0;

/// Indicates which color channel we want to edit.
#[derive(Component, Default, Copy, Clone, Reflect)]
#[reflect(Component, Default, Clone)]
pub enum ColorChannel {
    /// Editing the RGB red channel (0..=1)
    #[default]
    Red,
    /// Editing the RGB green channel (0..=1)
    Green,
    /// Editing the RGB blue channel (0..=1)
    Blue,
    /// Editing the hue channel (0..=360)
    HslHue,
    /// Editing the chroma / saturation channel (0..=1)
    HslSaturation,
    /// Editing the luminance channel (0..=1)
    HslLightness,
    /// Editing the alpha channel (0..=1)
    Alpha,
}

impl ColorChannel {
    /// Return the range of this color channel.
    pub fn range(&self) -> SliderRange {
        match self {
            ColorChannel::Red
            | ColorChannel::Green
            | ColorChannel::Blue
            | ColorChannel::Alpha
            | ColorChannel::HslSaturation
            | ColorChannel::HslLightness => SliderRange::new(0., 1.),
            ColorChannel::HslHue => SliderRange::new(0., 360.),
        }
    }

    /// Return the color endpoints and midpoint of the gradient. This is determined by both the
    /// channel being edited and the base color.
    pub fn gradient_ends(&self, base_color: Color) -> (Color, Color, Color) {
        match self {
            ColorChannel::Red => {
                let base_rgb = base_color.to_srgba();
                (
                    Color::srgb(0.0, base_rgb.green, base_rgb.blue),
                    Color::srgb(0.5, base_rgb.green, base_rgb.blue),
                    Color::srgb(1.0, base_rgb.green, base_rgb.blue),
                )
            }

            ColorChannel::Green => {
                let base_rgb = base_color.to_srgba();
                (
                    Color::srgb(base_rgb.red, 0.0, base_rgb.blue),
                    Color::srgb(base_rgb.red, 0.5, base_rgb.blue),
                    Color::srgb(base_rgb.red, 1.0, base_rgb.blue),
                )
            }

            ColorChannel::Blue => {
                let base_rgb = base_color.to_srgba();
                (
                    Color::srgb(base_rgb.red, base_rgb.green, 0.0),
                    Color::srgb(base_rgb.red, base_rgb.green, 0.5),
                    Color::srgb(base_rgb.red, base_rgb.green, 1.0),
                )
            }

            ColorChannel::HslHue => (
                Color::hsl(0.0 + 0.0001, 1.0, 0.5),
                Color::hsl(180.0, 1.0, 0.5),
                Color::hsl(360.0 - 0.0001, 1.0, 0.5),
            ),

            ColorChannel::HslSaturation => {
                let base_hsla: Hsla = base_color.into();
                (
                    Color::hsl(base_hsla.hue, 0.0, base_hsla.lightness),
                    Color::hsl(base_hsla.hue, 0.5, base_hsla.lightness),
                    Color::hsl(base_hsla.hue, 1.0, base_hsla.lightness),
                )
            }

            ColorChannel::HslLightness => {
                let base_hsla: Hsla = base_color.into();
                (
                    Color::hsl(base_hsla.hue, base_hsla.saturation, 0.0),
                    Color::hsl(base_hsla.hue, base_hsla.saturation, 0.5),
                    Color::hsl(base_hsla.hue, base_hsla.saturation, 1.0),
                )
            }

            ColorChannel::Alpha => (
                base_color.with_alpha(0.),
                base_color.with_alpha(0.5),
                base_color.with_alpha(1.),
            ),
        }
    }
}

/// Used to store the color channels that we are not editing: the components of the color
/// that are constant for this slider.
#[derive(Component, Default, Clone, Reflect)]
#[reflect(Component, Default, Clone)]
pub struct SliderBaseColor(pub Color);

/// A color slider widget.
///
/// This is spawnable by inheriting it as a "scene component" with optional [`FeathersColorSliderProps`].
///
/// # Emitted events
///
/// * [`bevy_ui_widgets::ValueChange<f32>`] when the slider value is changed.
///
///  These events can be disabled by adding an [`bevy_ui::InteractionDisabled`] component to the entity
#[derive(SceneComponent, Default, Clone)]
#[scene(FeathersColorSliderProps)]
#[derive(Reflect)]
#[reflect(Component, Default, Clone)]
pub struct FeathersColorSlider;

/// Props used to construct a [`FeathersColorSlider`] scene.
#[derive(Clone)]
pub struct FeathersColorSliderProps {
    /// Slider current value
    pub value: f32,
    /// Which color component we're editing
    pub channel: ColorChannel,
}

impl Default for FeathersColorSliderProps {
    fn default() -> Self {
        Self {
            value: 0.0,
            channel: ColorChannel::Alpha,
        }
    }
}

/// A color slider widget.
#[derive(Component, Default, Clone)]
#[require(Slider, SliderBaseColor(Color::WHITE))]
#[derive(Reflect)]
#[reflect(Component, Default, Clone)]
pub struct ColorSlider {
    /// Which channel is being edited by this slider.
    pub channel: ColorChannel,
}

/// Marker for the track
#[derive(Component, Default, Clone, Reflect)]
#[reflect(Component, Default, Clone)]
struct ColorSliderTrack;

/// Marker for the thumb
#[derive(Component, Default, Clone, Reflect)]
#[reflect(Component, Default, Clone)]
struct ColorSliderThumb;

impl FeathersColorSlider {
    fn scene(props: FeathersColorSliderProps) -> impl Scene {
        bsn! {
            Node {
                display: Display::Flex,
                flex_direction: FlexDirection::Row,
                height: px(SLIDER_HEIGHT),
                align_items: AlignItems::Stretch,
                flex_grow: 1.0,
            }
            Slider {
                track_click: TrackClick::Snap,
                orientation: SliderOrientation::Horizontal,
            }
            ColorSlider {
                channel: {props.channel},
            }
            SliderValue({props.value})
            template_value(props.channel.range())
            EntityCursor::System(bevy_window::SystemCursorIcon::Pointer)
            TabIndex(0)
            FocusIndicator
            Children [
                // track
                (
                    Node {
                        position_type: PositionType::Absolute,
                        left: px(0),
                        right: px(0),
                        top: px(TRACK_PADDING),
                        bottom: px(TRACK_PADDING),
                        border_radius: {RoundedCorners::All.to_border_radius(TRACK_RADIUS)},
                    }
                    ColorSliderTrack
                    AlphaPattern
                    MaterialNode::<AlphaPatternMaterial>
                    Children [
                        // Left endcap
                        (
                            Node {
                                width: px(THUMB_SIZE * 0.5),
                                border_radius: {RoundedCorners::Left.to_border_radius(TRACK_RADIUS)},
                            }
                            BackgroundColor(palette::X_AXIS)
                        ),
                        // Track with gradient
                        (
                            Node {
                                flex_grow: 1.0,
                            }
                            BackgroundGradient(vec![Gradient::Linear(LinearGradient {
                                angle: PI * 0.5,
                                stops: vec![
                                    ColorStop::new(Color::NONE, percent(0)),
                                    ColorStop::new(Color::NONE, percent(50)),
                                    ColorStop::new(Color::NONE, percent(100)),
                                ],
                                color_space: InterpolationColorSpace::Srgba,
                            })])
                            ZIndex(1)
                            Children [(
                                Node {
                                    position_type: PositionType::Absolute,
                                    left: percent(0),
                                    top: percent(50),
                                    width: px(THUMB_SIZE),
                                    height: px(THUMB_SIZE),
                                    border: px(2),
                                    border_radius: BorderRadius::MAX,
                                }
                                SliderThumb
                                ColorSliderThumb
                                BorderColor::all(palette::WHITE)
                                Outline {
                                    width: px(1),
                                    offset: px(0),
                                    color: palette::BLACK
                                }
                                UiTransform::from_translation(Val2::percent(-50., -50.))
                            )]
                        ),
                        // Right endcap
                        (
                            Node {
                                width: px(THUMB_SIZE * 0.5),
                                border_radius: {RoundedCorners::Right.to_border_radius(TRACK_RADIUS)},
                            }
                            BackgroundColor(palette::Z_AXIS)
                        )
                    ]
                )
            ]
        }
    }
}

/// Spawn a new slider widget.
///
/// # Arguments
///
/// * `props` - construction properties for the slider.
/// * `overrides` - a bundle of components that are merged in with the normal slider components.
///
/// # Emitted events
///
/// * [`bevy_ui_widgets::ValueChange<f32>`] when the slider value is changed.
///
///  These events can be disabled by adding an [`bevy_ui::InteractionDisabled`] component to the entity
#[deprecated(since = "0.19.0", note = "Use the color_slider() BSN function")]
pub fn color_slider_bundle<B: Bundle>(
    props: FeathersColorSliderProps,
    overrides: B,
) -> impl Bundle {
    (
        Node {
            display: Display::Flex,
            flex_direction: FlexDirection::Row,
            height: px(SLIDER_HEIGHT),
            align_items: AlignItems::Stretch,
            flex_grow: 1.0,
            ..Default::default()
        },
        Slider {
            track_click: TrackClick::Snap,
            orientation: SliderOrientation::Horizontal,
        },
        ColorSlider {
            channel: props.channel,
        },
        SliderValue(props.value),
        props.channel.range(),
        EntityCursor::System(bevy_window::SystemCursorIcon::Pointer),
        TabIndex(0),
        FocusIndicator,
        overrides,
        children![
            // track
            (
                Node {
                    position_type: PositionType::Absolute,
                    left: px(0),
                    right: px(0),
                    top: px(TRACK_PADDING),
                    bottom: px(TRACK_PADDING),
                    border_radius: RoundedCorners::All.to_border_radius(TRACK_RADIUS),
                    ..Default::default()
                },
                ColorSliderTrack,
                AlphaPattern,
                MaterialNode::<AlphaPatternMaterial>(Handle::default()),
                children![
                    // Left endcap
                    (
                        Node {
                            width: px(THUMB_SIZE * 0.5),
                            border_radius: RoundedCorners::Left.to_border_radius(TRACK_RADIUS),
                            ..Default::default()
                        },
                        BackgroundColor(palette::X_AXIS),
                    ),
                    // Track with gradient
                    (
                        Node {
                            flex_grow: 1.0,
                            ..Default::default()
                        },
                        BackgroundGradient(vec![Gradient::Linear(LinearGradient {
                            angle: PI * 0.5,
                            stops: vec![
                                ColorStop::new(Color::NONE, percent(0)),
                                ColorStop::new(Color::NONE, percent(50)),
                                ColorStop::new(Color::NONE, percent(100)),
                            ],
                            color_space: InterpolationColorSpace::Srgba,
                        })]),
                        ZIndex(1),
                        children![(
                            Node {
                                position_type: PositionType::Absolute,
                                left: percent(0),
                                top: percent(50),
                                width: px(THUMB_SIZE),
                                height: px(THUMB_SIZE),
                                border: UiRect::all(px(2)),
                                border_radius: BorderRadius::MAX,
                                ..Default::default()
                            },
                            SliderThumb,
                            ColorSliderThumb,
                            BorderColor::all(palette::WHITE),
                            Outline {
                                width: px(1),
                                offset: px(0),
                                color: palette::BLACK
                            },
                            UiTransform::from_translation(Val2::new(percent(-50), percent(-50),))
                        )]
                    ),
                    // Right endcap
                    (
                        Node {
                            width: px(THUMB_SIZE * 0.5),
                            border_radius: RoundedCorners::Right.to_border_radius(TRACK_RADIUS),
                            ..Default::default()
                        },
                        BackgroundColor(palette::Z_AXIS),
                    ),
                ]
            ),
        ],
    )
}

fn update_slider_pos(
    mut q_sliders: Query<
        (Entity, &SliderValue, &SliderRange),
        (
            With<ColorSlider>,
            Or<(Changed<SliderValue>, Changed<SliderRange>)>,
        ),
    >,
    q_children: Query<&Children>,
    mut q_slider_thumb: Query<&mut Node, With<ColorSliderThumb>>,
) {
    for (slider_ent, value, range) in q_sliders.iter_mut() {
        for child in q_children.iter_descendants(slider_ent) {
            if let Ok(mut thumb_node) = q_slider_thumb.get_mut(child) {
                thumb_node.left = percent(range.thumb_position(value.0) * 100.0);
            }
        }
    }
}

fn update_track_color(
    mut q_sliders: Query<(Entity, &ColorSlider, &SliderBaseColor), Changed<SliderBaseColor>>,
    q_children: Query<&Children>,
    q_track: Query<(), With<ColorSliderTrack>>,
    mut q_background: Query<&mut BackgroundColor>,
    mut q_gradient: Query<&mut BackgroundGradient>,
) {
    for (slider_ent, slider, SliderBaseColor(base_color)) in q_sliders.iter_mut() {
        let (start, middle, end) = slider.channel.gradient_ends(*base_color);
        if let Some(track_ent) = q_children
            .iter_descendants(slider_ent)
            .find(|ent| q_track.contains(*ent))
        {
            let Ok(track_children) = q_children.get(track_ent) else {
                continue;
            };

            if let Ok(mut cap_bg) = q_background.get_mut(track_children[0]) {
                cap_bg.0 = start;
            }

            if let Ok(mut gradient) = q_gradient.get_mut(track_children[1])
                && let [Gradient::Linear(linear_gradient)] = &mut gradient.0[..]
            {
                linear_gradient.stops[0].color = start;
                linear_gradient.stops[1].color = middle;
                linear_gradient.stops[2].color = end;
                linear_gradient.color_space = match slider.channel {
                    ColorChannel::Red | ColorChannel::Green | ColorChannel::Blue => {
                        InterpolationColorSpace::Srgba
                    }
                    ColorChannel::HslHue
                    | ColorChannel::HslLightness
                    | ColorChannel::HslSaturation => InterpolationColorSpace::Hsla,
                    ColorChannel::Alpha => match base_color {
                        Color::Srgba(_) => InterpolationColorSpace::Srgba,
                        Color::LinearRgba(_) => InterpolationColorSpace::LinearRgba,
                        Color::Oklaba(_) => InterpolationColorSpace::Oklaba,
                        Color::Oklcha(_) => InterpolationColorSpace::OklchaLong,
                        Color::Hsla(_) | Color::Hsva(_) => InterpolationColorSpace::Hsla,
                        _ => {
                            warn_once!("Unsupported color space for ColorSlider: {:?}", base_color);
                            InterpolationColorSpace::Srgba
                        }
                    },
                };
            }

            if let Ok(mut cap_bg) = q_background.get_mut(track_children[2]) {
                cap_bg.0 = end;
            }
        }
    }
}

/// Plugin which registers the systems for updating the slider styles.
pub struct ColorSliderPlugin;

impl Plugin for ColorSliderPlugin {
    fn build(&self, app: &mut bevy_app::App) {
        app.add_systems(
            PreUpdate,
            (update_slider_pos, update_track_color).in_set(PickingSystems::Last),
        );
    }
}