Easy bind color and etc for visuals

[arewerage]

Came up with a way that allows you not to duplicate code when you write a visual display (Hover, Unhover, Press, Release). Now you'll see:

public static class UIBlockExtensions
{
    public static void AddVisualsGestures<TVisuals>(this UIBlock target) where TVisuals : VisualsBase
    {
        target.AddGestureHandler<Gesture.OnHover, TVisuals>(VisualsBase.HandleHovered);
        target.AddGestureHandler<Gesture.OnUnhover, TVisuals>(VisualsBase.HandleUnhovered);
        target.AddGestureHandler<Gesture.OnPress, TVisuals>(VisualsBase.HandlePressed);
        target.AddGestureHandler<Gesture.OnRelease, TVisuals>(VisualsBase.HandleReleased);
    }
    
    public static void RemoveVisualsGestures<TVisuals>(this UIBlock target) where TVisuals : VisualsBase
    {
        target.RemoveGestureHandler<Gesture.OnHover, TVisuals>(VisualsBase.HandleHovered);
        target.RemoveGestureHandler<Gesture.OnUnhover, TVisuals>(VisualsBase.HandleUnhovered);
        target.RemoveGestureHandler<Gesture.OnPress, TVisuals>(VisualsBase.HandlePressed);
        target.RemoveGestureHandler<Gesture.OnRelease, TVisuals>(VisualsBase.HandleReleased);
    }
}

A basic visual control class:

[Serializable, TypeMenuPath("Sandbox")]
public abstract class VisualsBase : ItemVisuals
{
    [field: SerializeField] protected UIBlock2D Background { get; private set; }
    protected ColorPalette ColorPalette { get; set; }

    #region Hovered

    public static void HandleHovered(Gesture.OnHover evt, VisualsBase target, int index)
    {
        HandleHovered(evt, target);
    }

    public static void HandleHovered(Gesture.OnHover evt, VisualsBase target)
    {
        target.UpdateVisualsState(VisualStateTypeId.Hovered);
    }

    #endregion

    #region Unhovered

    public static void HandleUnhovered(Gesture.OnUnhover evt, VisualsBase target, int index)
    {
        HandleUnhovered(evt, target);
    }

    public static void HandleUnhovered(Gesture.OnUnhover evt, VisualsBase target)
    {
        target.UpdateVisualsState(VisualStateTypeId.Default);
    }

    #endregion

    #region Pressed

    public static void HandlePressed(Gesture.OnPress evt, VisualsBase target, int index)
    {
        HandlePressed(evt, target);
    }

    public static void HandlePressed(Gesture.OnPress evt, VisualsBase target)
    {
        target.UpdateVisualsState(VisualStateTypeId.Pressed);
    }

    #endregion

    #region Released

    public static void HandleReleased(Gesture.OnRelease evt, VisualsBase target, int index)
    {
        HandleReleased(evt, target);
    }

    public static void HandleReleased(Gesture.OnRelease evt, VisualsBase target)
    {
        target.UpdateVisualsState(VisualStateTypeId.Hovered);
    }

    #endregion

    public virtual void Reset(UIDataBase data, ColorPalette colors)
    {
        ColorPalette = colors;
        UpdateVisualsState(VisualStateTypeId.Default);
        UpdateVisualsData(data);
    }

    public virtual void UpdateVisualsData(UIDataBase data) { }

    protected virtual void UpdateVisualsState(VisualStateTypeId visualStateTypeId)
    {
        switch (visualStateTypeId)
        {
            case VisualStateTypeId.Hovered:
                Background.Color = ColorPalette.HoveredColor;
                Background.BodyEnabled = true;

                break;
            case VisualStateTypeId.Pressed:
                Background.Color = ColorPalette.PressedColor;

                break;
            default:
                Background.BodyEnabled = false;

                break;
        }
    }
}

Now you can create an heir (for example):

[Serializable]
public class LabelVisuals : VisualsBase
{
    [field: SerializeField] protected TextBlock Label { get; private set; }

    public override void Reset(UIDataBase data, ColorPalette colors)
    {
        base.Reset(data, colors);
        Label.Text = data.Label;
    }

    protected override void UpdateVisualsState(VisualStateTypeId visualStateTypeId)
    {
        base.UpdateVisualsState(visualStateTypeId);

        Label.Color = visualStateTypeId switch
        {
            VisualStateTypeId.Hovered => ColorPalette.DefaultColor,
            VisualStateTypeId.Default => ColorPalette.HoveredColor,
            _ => Label.Color
        };
    }
}

[Serializable]
public class SliderVisuals : LabelVisuals
{
    [field: SerializeField] public UIBlock2D BackgroundBar { get; private set; }
    [field: SerializeField] protected UIBlock2D FillBar { get; private set; }
    [field: SerializeField] protected UIBlock2D Knob { get; private set; }

    public override void UpdateVisualsData(UIDataBase data)
    {
        if (data is not SliderData sliderData)
            return;

        float min = sliderData.Min;
        float max = sliderData.Max;

        float percentFilled = math.clamp((sliderData.Value - min) / (max - min), 0f, 1f);

        FillBar.Size.X.Percent =
            math.clamp(percentFilled * (1 - FillBar.CalculatedMargin.X.Sum().Percent), 0f, 1f);
    }

    protected override void UpdateVisualsState(VisualStateTypeId visualStateTypeId)
    {
        base.UpdateVisualsState(visualStateTypeId);
        
        switch (visualStateTypeId)
        {
            case VisualStateTypeId.Hovered:
                BackgroundBar.Color = ColorPalette.DefaultColor;
                FillBar.Color = ColorPalette.DefaultColor;
                Knob.Color = ColorPalette.DefaultColor;

                break;
            case VisualStateTypeId.Default:
                BackgroundBar.Color = ColorPalette.HoveredColor;
                FillBar.Color = ColorPalette.HoveredColor;
                Knob.Color = ColorPalette.HoveredColor;
                
                break;
        }
    }
}

At the end, you can just bind all the controls by base class in the script, and get a visual representation for each element, which is an heir (i.e. no need to bind separately for each and easy to expand on requirements):

public class MenuScreen : MonoBehaviour
{
    [SerializeField] private UIBlock _root;

    private void OnEnable()
    {
        _root.AddVisualsGestures<VisualsBase>();
    }

    private void OnDisable()
    {
        _root.RemoveVisualsGestures<VisualsBase>();
    }
}

What do you think? Maybe there is something to improve?