How to make my own VisualElement? (Slide Toggle & Min Max Slider with visible values)

Unity Engine
, ,
4

Here is the code for my MinMaxSlider. Everything seems to work fine but I am not very sure of the code and its good practice. If you have any advise, I would be happy to read you.

public class MinMaxSlider : VisualElement {

    public new class UxmlFactory : UxmlFactory<MinMaxSlider, UxmlTraits> { }
    public new class UxmlTraits : VisualElement.UxmlTraits
    {
        private UxmlStringAttributeDescription m_Label = new UxmlStringAttributeDescription { name = "label", defaultValue = "Min Max Slider" };
        private UxmlFloatAttributeDescription m_MinValue = new UxmlFloatAttributeDescription { name = "min-value", defaultValue = 0 };
        private UxmlFloatAttributeDescription m_MaxValue = new UxmlFloatAttributeDescription { name = "max-value", defaultValue = 60 };
        private UxmlFloatAttributeDescription m_LowLimit = new UxmlFloatAttributeDescription { name = "low-limit", defaultValue = 0 };
        private UxmlFloatAttributeDescription m_MaxLimit = new UxmlFloatAttributeDescription { name = "hight-limit", defaultValue = 100 };

        public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
        {
            base.Init(ve, bag, cc);

            MinMaxSlider minMaxSlider = ve as MinMaxSlider;

            minMaxSlider.label = m_Label.GetValueFromBag(bag, cc);
            minMaxSlider.minValue = m_MinValue.GetValueFromBag(bag, cc);
            minMaxSlider.maxValue = m_MaxValue.GetValueFromBag(bag, cc);
            minMaxSlider.lowLimit = m_LowLimit.GetValueFromBag(bag, cc);
            minMaxSlider.hightLimit = m_MaxLimit.GetValueFromBag(bag, cc);
        }
    }

    Label labelField;
    UnityEngine.UIElements.MinMaxSlider slider;
    FloatField minValueField;
    FloatField maxValueField;

    public string label { get => labelField.text; set => labelField.text = value; }

    public Vector2 value
    {
        get => slider.value;

        set => slider.value = value;
    }

    public float minValue
    {
        get => slider.minValue;

        set {
            if (value < lowLimit)
                slider.minValue = lowLimit;
            else if (value > maxValue)
                slider.minValue = maxValue;
            else
                slider.minValue = value;

            minValueField.value = slider.minValue;
        }
    }

    public float maxValue
    {
        get => slider.maxValue;
       
        set {
            if (value < minValue)
                slider.maxValue = minValue;
            else if (value > hightLimit)
                slider.maxValue = hightLimit;
            else
                slider.maxValue = value;

            maxValueField.value = slider.maxValue;
        }
    }

    public float lowLimit
    {
        get => slider.lowLimit;
       
        set {
            slider.lowLimit = value < hightLimit ? value : hightLimit;

            if (minValue < slider.lowLimit)
                minValue = slider.lowLimit;

            if (maxValue < slider.lowLimit)
                maxValue = slider.lowLimit;
        }
    }

    public float hightLimit
    {
        get => slider.highLimit;
       
        set {
            slider.highLimit = value > lowLimit ? value : lowLimit;

            if (maxValue > slider.highLimit)
                maxValue = slider.highLimit;

            if (minValue > slider.highLimit)
                minValue = slider.highLimit;
        }
    }

    public MinMaxSlider() : this("Min Max Slider", 0, 40, 0, 100)
    {
       
    }

    public MinMaxSlider(string label, float minValue, float maxValue, float lowLimit, float hightLimit)
    {
        VisualTreeAsset document = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/PrefabPlacer/UI Toolkit/MinMaxSlider.uxml");
        document.CloneTree(this);

        labelField = this.Q<Label>("label");
        slider = this.Q<UnityEngine.UIElements.MinMaxSlider>("slider");
        minValueField = this.Q<FloatField>("minValue");
        maxValueField = this.Q<FloatField>("maxValue");

        slider.RegisterValueChangedCallback((evt) =>
        {
            minValueField.value = evt.newValue.x;
            maxValueField.value = evt.newValue.y;
        });

        minValueField.RegisterValueChangedCallback((evt) =>
        {
            this.minValue = evt.newValue;
        });

        maxValueField.RegisterValueChangedCallback((evt) =>
        {
            this.maxValue = evt.newValue;
        });

        this.label = label;
        this.minValue = minValue;
        this.maxValue = maxValue;
        this.lowLimit = lowLimit;
        this.hightLimit = hightLimit;
    }
}