SNumericEntryBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/Attribute.h"
#include "InputCoreTypes.h"
#include "Layout/Margin.h"
#include "Fonts/SlateFontInfo.h"
#include "Layout/Visibility.h"
#include "Widgets/SNullWidget.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Styling/SlateColor.h"
#include "Input/Events.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Widgets/SCompoundWidget.h"
#include "Styling/CoreStyle.h"
#include "Widgets/Input/NumericTypeInterface.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/Layout/SBorder.h"
#include "Styling/SlateTypes.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/Input/SEditableText.h"
#include "Widgets/Input/SSpinBox.h"
#include "Widgets/Input/SCheckBox.h"
#include "Widgets/Colors/SColorBlock.h"
#include "Containers/UnrealString.h"
 
template<typename NumericType>
class SNumericEntryBox : public SCompoundWidget
{
public: 
 
    static const FLinearColor RedLabelBackgroundColor;
    static const FLinearColor GreenLabelBackgroundColor;
    static const FLinearColor BlueLabelBackgroundColor;
    static const FLinearColor LilacLabelBackgroundColor;
    static const FText DefaultUndeterminedString;
 
    DECLARE_DELEGATE_OneParam(FOnValueChanged, NumericType /*NewValue*/);
 
    DECLARE_DELEGATE_TwoParams(FOnValueCommitted, NumericType /*NewValue*/, ETextCommit::Type /*CommitType*/);
 
    DECLARE_DELEGATE_OneParam(FOnUndeterminedValueChanged, FText /*NewValue*/ );
 
    DECLARE_DELEGATE_TwoParams(FOnUndeterminedValueCommitted, FText /*NewValue*/, ETextCommit::Type /*CommitType*/);
 
    DECLARE_DELEGATE_FourParams(FOnDynamicSliderMinMaxValueChanged, NumericType, TWeakPtr<SWidget>, bool, bool);
 
    enum class ELabelLocation
    {
        // Outside the bounds of the editable area of this box. Usually preferred for text based labels
        Outside,
        // Inside the bounds of the editable area of this box. Usually preferred for non-text based labels
        // when a spin box is used the label will appear on top of the spin box in this case
        Inside
    };
public:
 
    SLATE_BEGIN_ARGS( SNumericEntryBox<NumericType> )
        : _EditableTextBoxStyle( &FAppStyle::Get().GetWidgetStyle<FEditableTextBoxStyle>("NormalEditableTextBox") )
        , _SpinBoxStyle(&FAppStyle::Get().GetWidgetStyle<FSpinBoxStyle>("NumericEntrySpinBox") )
        , _Label()
        , _LabelVAlign( VAlign_Fill )
        , _Justification(ETextJustify::Left)
        , _LabelLocation(ELabelLocation::Outside)
        , _LabelPadding(FMargin(3.f,0.f) )
        , _BorderForegroundColor(FAppStyle::Get().GetWidgetStyle<FSpinBoxStyle>("NumericEntrySpinBox").ForegroundColor)
        , _BorderBackgroundColor(FLinearColor::White)
        , _UndeterminedString( SNumericEntryBox<NumericType>::DefaultUndeterminedString )
        , _AllowSpin(false)
        , _ShiftMultiplier(10.f)
        , _CtrlMultiplier(0.1f)
        , _SupportDynamicSliderMaxValue(false)
        , _SupportDynamicSliderMinValue(false)
        , _Delta(NumericType(0))
        , _MinFractionalDigits(DefaultMinFractionalDigits)
        , _MaxFractionalDigits(DefaultMaxFractionalDigits)
        , _MinValue(TNumericLimits<NumericType>::Lowest())
        , _MaxValue(TNumericLimits<NumericType>::Max())
        , _MinSliderValue(NumericType(0))
        , _MaxSliderValue(NumericType(100))
        , _SliderExponent(1.f)
        , _AllowWheel(true)
        , _PreventThrottling(false)
        , _BroadcastValueChangesPerKey(false)
        , _MinDesiredValueWidth(0.f)
        , _DisplayToggle(false)
        , _ToggleChecked(ECheckBoxState::Checked)
        , _TogglePadding(FMargin(1.f,0.f,1.f,0.f) )
        , _ToolTipTextFormat(TOptional<FTextFormat>())
    {}
 
        SLATE_STYLE_ARGUMENT( FEditableTextBoxStyle, EditableTextBoxStyle )
 
        
        SLATE_STYLE_ARGUMENT( FSpinBoxStyle, SpinBoxStyle )
 
        
        SLATE_NAMED_SLOT( FArguments, Label )
        SLATE_ARGUMENT( EVerticalAlignment, LabelVAlign )
        SLATE_ATTRIBUTE(ETextJustify::Type, Justification)
 
        SLATE_ARGUMENT(ELabelLocation, LabelLocation)
        SLATE_ARGUMENT( FMargin, LabelPadding )
        SLATE_ARGUMENT( FSlateColor, BorderForegroundColor )
        SLATE_ARGUMENT( FSlateColor, BorderBackgroundColor )
        SLATE_ATTRIBUTE( TOptional<NumericType>, Value )
        SLATE_ARGUMENT( FText, UndeterminedString )
        SLATE_ATTRIBUTE( FSlateFontInfo, Font )
        SLATE_ARGUMENT( bool, AllowSpin )
        SLATE_ATTRIBUTE_DEPRECATED( int32, ShiftMouseMovePixelPerDelta, 5.4, "Shift Mouse Move Pixel Per Delta is deprecated, please use ShiftMultiplier" )
        SLATE_ATTRIBUTE( float, ShiftMultiplier )
        SLATE_ATTRIBUTE( float, CtrlMultiplier )
        SLATE_ATTRIBUTE( int32, LinearDeltaSensitivity)
        SLATE_ATTRIBUTE(bool, SupportDynamicSliderMaxValue)
        SLATE_ATTRIBUTE(bool, SupportDynamicSliderMinValue)
        SLATE_EVENT(FOnDynamicSliderMinMaxValueChanged, OnDynamicSliderMaxValueChanged)
        SLATE_EVENT(FOnDynamicSliderMinMaxValueChanged, OnDynamicSliderMinValueChanged)
        SLATE_ATTRIBUTE( NumericType, Delta )
        SLATE_ATTRIBUTE(TOptional< int32 >, MinFractionalDigits)
        SLATE_ATTRIBUTE(TOptional< int32 >, MaxFractionalDigits)
        SLATE_ATTRIBUTE( TOptional< NumericType >, MinValue )
        SLATE_ATTRIBUTE( TOptional< NumericType >, MaxValue )
        SLATE_ATTRIBUTE( TOptional< NumericType >, MinSliderValue )
        SLATE_ATTRIBUTE( TOptional< NumericType >, MaxSliderValue )
        SLATE_ATTRIBUTE( float, SliderExponent )
        SLATE_ATTRIBUTE(NumericType, SliderExponentNeutralValue )
        SLATE_ARGUMENT( bool, AllowWheel )
        SLATE_ARGUMENT(bool, PreventThrottling)
        SLATE_ARGUMENT( bool, BroadcastValueChangesPerKey)
        SLATE_ATTRIBUTE( TOptional< NumericType >, WheelStep )
        SLATE_ATTRIBUTE( float, MinDesiredValueWidth )
        SLATE_ATTRIBUTE( FMargin, OverrideTextMargin )
        SLATE_EVENT( FOnValueChanged, OnValueChanged )
        SLATE_EVENT( FOnValueCommitted, OnValueCommitted )
        SLATE_EVENT( FOnUndeterminedValueChanged, OnUndeterminedValueChanged )
        SLATE_EVENT( FOnUndeterminedValueCommitted, OnUndeterminedValueCommitted )
        SLATE_EVENT( FSimpleDelegate, OnBeginSliderMovement )
        SLATE_EVENT( FOnValueChanged, OnEndSliderMovement )     
        SLATE_EVENT( FMenuExtensionDelegate, ContextMenuExtender )
        SLATE_ARGUMENT( TSharedPtr< INumericTypeInterface<NumericType> >, TypeInterface )
        SLATE_ARGUMENT( bool, DisplayToggle )
        SLATE_ATTRIBUTE( ECheckBoxState, ToggleChecked )
        SLATE_EVENT( FOnCheckStateChanged, OnToggleChanged )
        SLATE_ARGUMENT( FMargin, TogglePadding )
        SLATE_ATTRIBUTE(TOptional<FTextFormat>, ToolTipTextFormat)
 
    SLATE_END_ARGS()
    SNumericEntryBox()
    {
    }
 
    void Construct( const FArguments& InArgs )
    {
        check(InArgs._EditableTextBoxStyle);
 
        OnValueChanged = InArgs._OnValueChanged;
        OnValueCommitted = InArgs._OnValueCommitted;
        OnUndeterminedValueChanged = InArgs._OnUndeterminedValueChanged;
        OnUndeterminedValueCommitted = InArgs._OnUndeterminedValueCommitted;
        ValueAttribute = InArgs._Value;
        UndeterminedString = InArgs._UndeterminedString;
        MinDesiredValueWidth = InArgs._MinDesiredValueWidth;
        BorderImageNormal = &InArgs._EditableTextBoxStyle->BackgroundImageNormal;
        BorderImageHovered = &InArgs._EditableTextBoxStyle->BackgroundImageHovered;
        BorderImageFocused = &InArgs._EditableTextBoxStyle->BackgroundImageFocused;
        Interface = InArgs._TypeInterface.IsValid() ? InArgs._TypeInterface : MakeShareable( new TDefaultNumericTypeInterface<NumericType> );
 
        if (InArgs._TypeInterface.IsValid() && Interface->GetOnSettingChanged())
        {
            Interface->GetOnSettingChanged()->AddSP(this, &SNumericEntryBox::ResetCachedValueString);
        }
 
        MinFractionalDigits = (InArgs._MinFractionalDigits.Get().IsSet()) ? InArgs._MinFractionalDigits : DefaultMinFractionalDigits;
        MaxFractionalDigits = (InArgs._MaxFractionalDigits.Get().IsSet()) ? InArgs._MaxFractionalDigits : DefaultMaxFractionalDigits;
        SetMinFractionalDigits(MinFractionalDigits);
        SetMaxFractionalDigits(MaxFractionalDigits);
 
        ToolTipTextFormat = InArgs._ToolTipTextFormat;
 
        CachedExternalValue = ValueAttribute.Get();
        if (CachedExternalValue.IsSet())
        {
            CachedValueString = Interface->ToString(CachedExternalValue.GetValue());
        }
        bCachedValueStringDirty = false;
 
        const bool bDisplayToggle = InArgs._DisplayToggle;
        if(bDisplayToggle)
        {
            SAssignNew(ToggleCheckBox, SCheckBox)
            .Padding(FMargin(0.f, 0.f, 2.f, 0.f))
            .IsChecked(InArgs._ToggleChecked)
            .OnCheckStateChanged(this, &SNumericEntryBox::HandleToggleCheckBoxChanged, InArgs._OnToggleChanged);
        }
 
        const bool bAllowSpin = InArgs._AllowSpin;
        TSharedPtr<SWidget> FinalWidget;
 
        if( bAllowSpin )
        {
            SAssignNew(SpinBox, SSpinBox<NumericType>)
                .Style(InArgs._SpinBoxStyle)
                .Font(InArgs._Font.IsSet() ? InArgs._Font : InArgs._EditableTextBoxStyle->TextStyle.Font)
                .Value(this, &SNumericEntryBox<NumericType>::OnGetValueForSpinBox)
                .Delta(InArgs._Delta)
                .ShiftMultiplier(InArgs._ShiftMultiplier)
                .CtrlMultiplier(InArgs._CtrlMultiplier)
                .LinearDeltaSensitivity(InArgs._LinearDeltaSensitivity)
                .SupportDynamicSliderMaxValue(InArgs._SupportDynamicSliderMaxValue)
                .SupportDynamicSliderMinValue(InArgs._SupportDynamicSliderMinValue)
                .OnDynamicSliderMaxValueChanged(InArgs._OnDynamicSliderMaxValueChanged)
                .OnDynamicSliderMinValueChanged(InArgs._OnDynamicSliderMinValueChanged)
                .OnValueChanged(OnValueChanged)
                .OnValueCommitted(OnValueCommitted)
                .MinFractionalDigits(MinFractionalDigits)
                .MaxFractionalDigits(MaxFractionalDigits)
                .MinSliderValue(InArgs._MinSliderValue)
                .MaxSliderValue(InArgs._MaxSliderValue)
                .MaxValue(InArgs._MaxValue)
                .MinValue(InArgs._MinValue)
                .ContextMenuExtender(InArgs._ContextMenuExtender)
                .SliderExponent(InArgs._SliderExponent)
                .SliderExponentNeutralValue(InArgs._SliderExponentNeutralValue)
                .EnableWheel(InArgs._AllowWheel)
                .PreventThrottling(InArgs._PreventThrottling)
                .BroadcastValueChangesPerKey(InArgs._BroadcastValueChangesPerKey)
                .WheelStep(InArgs._WheelStep)
                .OnBeginSliderMovement(InArgs._OnBeginSliderMovement)
                .OnEndSliderMovement(InArgs._OnEndSliderMovement)
                .MinDesiredWidth(InArgs._MinDesiredValueWidth)
                .TypeInterface(Interface)
                .ToolTipText(this, &SNumericEntryBox<NumericType>::GetToolTipText);
        }
 
        // Always create an editable text box.  In the case of an undetermined value being passed in, we cant use the spinbox.
        SAssignNew(EditableText, SEditableText)
            .Text(this, &SNumericEntryBox<NumericType>::OnGetValueForTextBox)
            .ToolTipText(this, &SNumericEntryBox<NumericType>::GetToolTipText)
            .ColorAndOpacity(InArgs._EditableTextBoxStyle->ForegroundColor)
            .Visibility(bAllowSpin ? EVisibility::Collapsed : EVisibility::Visible)
            .Font(InArgs._Font.IsSet() ? InArgs._Font : InArgs._EditableTextBoxStyle->TextStyle.Font)
            .SelectAllTextWhenFocused(true)
            .ClearKeyboardFocusOnCommit(false)
            .OnTextChanged(this, &SNumericEntryBox<NumericType>::OnTextChanged)
            .OnTextCommitted(this, &SNumericEntryBox<NumericType>::OnTextCommitted)
            .SelectAllTextOnCommit(true)
            .ContextMenuExtender(InArgs._ContextMenuExtender)
            .Justification(InArgs._Justification)
            .MinDesiredWidth(InArgs._MinDesiredValueWidth);
 
        TSharedRef<SOverlay> Overlay = SNew(SOverlay);
 
        // Add the spin box if we have one
        if( bAllowSpin )
        {
            Overlay->AddSlot()
                .HAlign(HAlign_Fill) 
                .VAlign(VAlign_Center) 
                [
                    SpinBox.ToSharedRef()
                ];
        }
 
 
        TAttribute<FMargin> TextMargin = InArgs._OverrideTextMargin.IsSet() ? InArgs._OverrideTextMargin : InArgs._EditableTextBoxStyle->Padding;
 
        Overlay->AddSlot()
            .HAlign(HAlign_Fill) 
            .VAlign(VAlign_Center)
            .Padding(TextMargin)
            [
                EditableText.ToSharedRef()
            ];
 
        TSharedPtr<SWidget> MainContents;
 
        const bool bHasLabel = InArgs._Label.Widget != SNullWidget::NullWidget;
 
        bool bHasInsideLabel = false;
        if (bHasLabel && InArgs._LabelLocation == ELabelLocation::Inside)
        {
            bHasInsideLabel = true;
 
            Overlay->AddSlot()
                .HAlign(HAlign_Left)
                .VAlign(InArgs._LabelVAlign)
                .Padding(InArgs._LabelPadding)
                [
                    InArgs._Label.Widget
                ];
        }
 
 
        if (bAllowSpin && !bHasInsideLabel)
        {
            MainContents = Overlay;
        }
        else 
        {
            MainContents =
                SNew(SBorder)
                .BorderImage(this, &SNumericEntryBox<NumericType>::GetBorderImage)
                .BorderBackgroundColor(InArgs._BorderBackgroundColor)
                .ForegroundColor(InArgs._BorderForegroundColor)
                .Padding(0.f)
                [
                    Overlay
                ];
        }
 
        if(!bHasLabel || bHasInsideLabel)
        {
            if(bDisplayToggle)
            {
                ChildSlot
                [
                    SNew(SHorizontalBox)
                    +SHorizontalBox::Slot()
                    .AutoWidth()
                    .HAlign(HAlign_Fill) 
                    .VAlign(VAlign_Center) 
                    .Padding(InArgs._TogglePadding)
                    [
                        ToggleCheckBox.ToSharedRef()
                    ]
                    + SHorizontalBox::Slot()
                    [
                        MainContents.ToSharedRef()
                    ]
                ];
            }
            else
            {
                ChildSlot
                [
                    MainContents.ToSharedRef()
                ];
            }
        }
        else
        {
            TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
 
            HorizontalBox->AddSlot()
            .AutoWidth()
            .HAlign(HAlign_Left)
            .VAlign(InArgs._LabelVAlign)
            .Padding(InArgs._LabelPadding)
            [
                InArgs._Label.Widget
            ];
 
            if(bDisplayToggle)
            {
                HorizontalBox->AddSlot()
                .AutoWidth()
                .HAlign(HAlign_Fill)
                .VAlign(VAlign_Center)
                .Padding(InArgs._TogglePadding)
                [
                    ToggleCheckBox.ToSharedRef()
                ];
            }
            
            HorizontalBox->AddSlot()
            [
                MainContents.ToSharedRef()
            ];
 
            ChildSlot
            [
                HorizontalBox
            ];
        }
 
        if (bDisplayToggle)
        {
            HandleToggleCheckBoxChanged(InArgs._ToggleChecked.Get(), FOnCheckStateChanged());
        }
    }
 
    static TSharedRef<SWidget> BuildLabel(TAttribute<FText> LabelText, const FSlateColor& ForegroundColor, const FSlateColor& BackgroundColor)
    {
        return
            SNew(SBorder)
            .Visibility(EVisibility::HitTestInvisible)
            .BorderImage(FCoreStyle::Get().GetBrush("NumericEntrySpinBox.Decorator"))
            .BorderBackgroundColor(BackgroundColor)
            .ForegroundColor(ForegroundColor)
            .VAlign(VAlign_Center)
            .HAlign(HAlign_Left)
            .Padding(FMargin(1.f, 0.f, 6.f, 0.f))
            [
                SNew(STextBlock)
                .Text(LabelText)
            ];
    }
 
 
    static TSharedRef<SWidget> BuildNarrowColorLabel(FLinearColor LabelColor)
    {
        return
            SNew(SBorder)
            .Visibility(EVisibility::HitTestInvisible)
            .BorderImage(FAppStyle::Get().GetBrush("NumericEntrySpinBox.NarrowDecorator"))
            .BorderBackgroundColor(LabelColor)
            .HAlign(HAlign_Left)
            .Padding(FMargin(2.0f, 0.0f, 0.0f, 0.0f));
    }
 
 
    TSharedPtr<SWidget> GetSpinBox() const { return SpinBox; }
 
    int32 GetMinFractionalDigits() const { return Interface->GetMinFractionalDigits(); }
    void SetMinFractionalDigits(const TAttribute<TOptional<int32>>& InMinFractionalDigits)
    {
        Interface->SetMinFractionalDigits((InMinFractionalDigits.Get().IsSet()) ? InMinFractionalDigits.Get() : MinFractionalDigits);
        bCachedValueStringDirty = true;
    }
 
    int32 GetMaxFractionalDigits() const { return Interface->GetMaxFractionalDigits(); }
    void SetMaxFractionalDigits(const TAttribute<TOptional<int32>>& InMaxFractionalDigits)
    {
        Interface->SetMaxFractionalDigits((InMaxFractionalDigits.Get().IsSet()) ? InMaxFractionalDigits.Get() : MaxFractionalDigits);
        bCachedValueStringDirty = true;
    }
 
private:
 
    //~ SWidget Interface
 
    virtual bool SupportsKeyboardFocus() const override
    {
        return StaticCastSharedPtr<SWidget>(EditableText)->SupportsKeyboardFocus();
    }
 
    virtual FReply OnFocusReceived( const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent ) override
    {
        FReply Reply = FReply::Handled();
 
        // The widget to forward focus to changes depending on whether we have a SpinBox or not.
        TSharedPtr<SWidget> FocusWidget;
        if (SpinBox.IsValid() && SpinBox->GetVisibility() == EVisibility::Visible) 
        {
            FocusWidget = SpinBox;
        }
        else
        {
            FocusWidget = EditableText;
        }
 
        if ( InFocusEvent.GetCause() != EFocusCause::Cleared )
        {
            // Forward keyboard focus to our chosen widget
            Reply.SetUserFocus(FocusWidget.ToSharedRef(), InFocusEvent.GetCause());
        }
 
        return Reply;
    }
 
    virtual FReply OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent ) override
    {
        FKey Key = InKeyEvent.GetKey();
 
        if( Key == EKeys::Escape && EditableText->HasKeyboardFocus() )
        {
            return FReply::Handled().SetUserFocus(SharedThis(this), EFocusCause::Cleared);
        }
 
        return FReply::Unhandled();
    }
 
private:
 
    FString GetLabel() const
    {
        // Should always be set if this is being called
        return LabelAttribute.Get().GetValue();
    }
 
    NumericType OnGetValueForSpinBox() const
    {
        const auto& Value = ValueAttribute.Get();
 
        // Get the value or 0 if its not set
        if( Value.IsSet() == true )
        {
            return Value.GetValue();
        }
 
        return 0;
    }
 
    void SetCachedString(const NumericType CurrentValue)
    {
        if (!CachedExternalValue.IsSet() || CachedExternalValue.GetValue() != CurrentValue || bCachedValueStringDirty)
        {
            CachedExternalValue = CurrentValue;
            CachedValueString = Interface->ToString(CurrentValue);
            bCachedValueStringDirty = false;
        }
    }
 
    FString GetCachedString(const NumericType CurrentValue) const
    {
        const bool bUseCachedString = CachedExternalValue.IsSet() && CurrentValue == CachedExternalValue.GetValue() && !bCachedValueStringDirty;
        return bUseCachedString ? CachedValueString : Interface->ToString(CurrentValue);  
    }
 
    FText GetToolTipText() const
    {
        const TOptional<NumericType>& Value = ValueAttribute.Get();
 
#if WITH_EDITOR
        if constexpr (std::is_floating_point_v<NumericType>)
        {
            if (Value.IsSet() && CachedValueString.Contains(TEXT("...")))
            {
                NumericType NumericValue = Value.GetValue();
                FString ValueScientificStr = FString::Printf(TEXT("%e"), NumericValue);
 
                // Dev Note: If you are seeing this message when not expected it can mean the following:
                // 1. Simple content / value change is needed assuming the ~1e-16 off value is not desired.
                // 2. If the above doesn't fix the issue, then there probably is an editor customization / some data writer that needs fixing
                // 3. If the value is a true denorm, smaller than 1.175e-38 / 2.225e-307 for floats / doubles respectively. There is a larger issue.
                //    In this case, it is possible that you may be reading from garbage / random memory not intended for floating point types.
 
                return FText::Format(NSLOCTEXT("SNumericEntryBox", "NearZeroWarning_ToolTip", "Exact value: {0}. Set value or reimport after updating source content to change."), FText::FromString(ValueScientificStr));
            }
        }
#endif // WITH_EDITOR
 
        if (Value.IsSet() == true)
        {
            NumericType CurrentValue = Value.GetValue();
 
            FText CurrentValueText = FText::FromString(GetCachedString(CurrentValue));
 
            if (ToolTipTextFormat.Get().IsSet())
            {
                return FText::Format(ToolTipTextFormat.Get().GetValue(), CurrentValueText);
            }
 
            return CurrentValueText;
        }
 
        return FText::GetEmpty();
    }
 
    FText OnGetValueForTextBox() const
    {
        if( EditableText->GetVisibility() == EVisibility::Visible )
        {
            const TOptional<NumericType>& Value = ValueAttribute.Get();
            if (Value.IsSet() == true)
            {
                return FText::FromString(GetCachedString(Value.GetValue()));
            }
            else
            {
                return UndeterminedString;
            }
        }
 
        // The box isnt visible, just return an empty Text
        return  FText::GetEmpty();
    }
 
 
    void OnTextChanged( const FText& NewValue )
    {
        const auto& Value = ValueAttribute.Get();
 
        if (Value.IsSet() || !OnUndeterminedValueChanged.IsBound())
        {
            SendChangesFromText( NewValue, false, ETextCommit::Default );
        }
        else
        {
            OnUndeterminedValueChanged.Execute(NewValue);
        }
    }
 
    void OnTextCommitted( const FText& NewValue, ETextCommit::Type CommitInfo )
    {
        const auto& Value = ValueAttribute.Get();
 
        if (Value.IsSet() || !OnUndeterminedValueCommitted.IsBound())
        {
            SendChangesFromText( NewValue, true, CommitInfo );
        }
        else
        {
            OnUndeterminedValueCommitted.Execute(NewValue, CommitInfo);
        }
    }
 
    const FSlateBrush* GetBorderImage() const
    {
        TSharedPtr<const SWidget> EditingWidget;
 
        if (SpinBox.IsValid() && SpinBox->GetVisibility() == EVisibility::Visible) 
        {
            EditingWidget = SpinBox;
        }
        else
        {
            EditingWidget = EditableText;
        }
 
        if ( EditingWidget->HasKeyboardFocus() )
        {
            return BorderImageFocused;
        }
 
        if ( EditingWidget->IsHovered() )
        {
            return BorderImageHovered;
        }
 
        return BorderImageNormal;
    }
 
    void SendChangesFromText( const FText& NewValue, bool bCommit, ETextCommit::Type CommitInfo )
    {
        if (NewValue.IsEmpty())
        {
            return;
        }
 
        TOptional<NumericType> ExistingValue = ValueAttribute.Get();
        TOptional<NumericType> NumericValue = Interface->FromString(NewValue.ToString(), ExistingValue.Get(0));
 
        if (NumericValue.IsSet())
        {
            SetCachedString(NumericValue.GetValue());
 
            if (bCommit)
            {
                OnValueCommitted.ExecuteIfBound(NumericValue.GetValue(), CommitInfo);
            }
            else
            {
                OnValueChanged.ExecuteIfBound(NumericValue.GetValue());
            }
        }
    }
 
    virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) override
    {
        // Update the cached value, if needed.
#if WITH_EDITOR
        if constexpr (std::is_floating_point_v<NumericType>)
        {
            if (!GetPersistentState().bIsInGameLayer && !Interface->GetIndicateNearlyInteger())
            {
                Interface->SetIndicateNearlyInteger(true);
                bCachedValueStringDirty = true;
 
                if (SpinBox.IsValid())
                {
                    SpinBox->ResetCachedValueString();
                }
            }
        }
#endif // WITH_EDITOR
 
        const TOptional<NumericType>& Value = ValueAttribute.Get();
        if (Value.IsSet() == true)
        {
            SetCachedString(Value.GetValue());
        }
        
        // Visibility toggle only matters if the spinbox is used
        if (SpinBox.IsValid())
        {
            if (Value.IsSet() == true)
            {
                if (SpinBox->GetVisibility() != EVisibility::Visible)
                {
                    // Set the visibility of the spinbox to visible if we have a valid value
                    SpinBox->SetVisibility( EVisibility::Visible );
                    // The text box should be invisible
                    EditableText->SetVisibility( EVisibility::Collapsed );
                }
            }
            else
            {
                // The value isn't set so the spinbox should be hidden and the text box shown
                SpinBox->SetVisibility(EVisibility::Collapsed);
                EditableText->SetVisibility(EVisibility::Visible);
            }
        }
    }
 
    bool IsToggleEnabled() const
    {
        if(!IsEnabled())
        {
            return false;
        }
        return ToggleCheckBox->IsChecked();
    }
    
    void HandleToggleCheckBoxChanged(ECheckBoxState InCheckState, FOnCheckStateChanged OnToggleChanged) const
    {
        if(SpinBox.IsValid())
        {
            SpinBox->SetEnabled(InCheckState == ECheckBoxState::Checked);
        }
        if(EditableText.IsValid())
        {
            EditableText->SetEnabled(InCheckState == ECheckBoxState::Checked);
        }
        if(OnToggleChanged.IsBound())
        {
            OnToggleChanged.Execute(InCheckState);
        }
    }
 
    void ResetCachedValueString() 
    { 
        if (ValueAttribute.Get().IsSet())
        {
            bCachedValueStringDirty = true;
        }
    }
 
private:
 
    static const int32 DefaultMinFractionalDigits;
 
    static const int32 DefaultMaxFractionalDigits;
 
    TAttribute< TOptional<FString > > LabelAttribute;
    TAttribute< TOptional<NumericType> > ValueAttribute;
    TSharedPtr<SCheckBox> ToggleCheckBox;
    TSharedPtr<SSpinBox<NumericType>> SpinBox;
    TSharedPtr<SEditableText> EditableText;
    FOnValueChanged OnValueChanged;
    FOnValueCommitted OnValueCommitted;
    FOnUndeterminedValueChanged OnUndeterminedValueChanged;
    FOnUndeterminedValueCommitted OnUndeterminedValueCommitted;
    FText UndeterminedString;
    const FSlateBrush* BorderImageNormal;
    const FSlateBrush* BorderImageHovered;
    const FSlateBrush* BorderImageFocused;
    TAttribute<float> MinDesiredValueWidth;
    TSharedPtr< INumericTypeInterface<NumericType> > Interface;
    TOptional<NumericType> CachedExternalValue;
    FString CachedValueString;
    bool bCachedValueStringDirty;
    TAttribute< TOptional<int32> > MinFractionalDigits;
    TAttribute< TOptional<int32> > MaxFractionalDigits;
    TAttribute< TOptional<FTextFormat> > ToolTipTextFormat;
};
 
 
template <typename NumericType>
const FLinearColor SNumericEntryBox<NumericType>::RedLabelBackgroundColor(0.594f,0.0197f,0.0f);
 
template <typename NumericType>
const FLinearColor SNumericEntryBox<NumericType>::GreenLabelBackgroundColor(0.1349f,0.3959f,0.0f);
 
template <typename NumericType>
const FLinearColor SNumericEntryBox<NumericType>::BlueLabelBackgroundColor(0.0251f,0.207f,0.85f);
 
template <typename NumericType>
const FLinearColor SNumericEntryBox<NumericType>::LilacLabelBackgroundColor(0.8f,0.121f,0.8f);
 
template <typename NumericType>
const FText SNumericEntryBox<NumericType>::DefaultUndeterminedString = FText::FromString(TEXT("---"));
 
template<typename NumericType>
const int32 SNumericEntryBox<NumericType>::DefaultMinFractionalDigits = 1;
 
template<typename NumericType>
const int32 SNumericEntryBox<NumericType>::DefaultMaxFractionalDigits = 6;