SSpinBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Fonts/SlateFontInfo.h"
#include "Framework/Application/SlateApplication.h"
#include "Framework/MultiBox/MultiBoxExtender.h"
#include "Input/CursorReply.h"
#include "Input/Events.h"
#include "Input/Reply.h"
#include "InputCoreTypes.h"
#include "Layout/Margin.h"
#include "Layout/Visibility.h"
#include "Misc/Attribute.h"
#include "Rendering/DrawElements.h"
#include "Styling/CoreStyle.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateTypes.h"
#include "Templates/IsIntegral.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Input/NumericTypeInterface.h"
#include "Widgets/Input/SEditableText.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/Text/STextBlock.h"
 
#include <limits>
 
namespace SpinBoxPrivate
{
    SLATE_API extern bool bUseSpinBoxMouseMoveOptimization;
}
 
/*
 * This function compute a slider position by simulating two log on both side of the neutral value
 * Example a slider going from 0.0 to 2.0 with a neutral value of 1.0, the user will have a lot of precision around the neutral value
 * on both side.
 |
 ||                              |
 | -_                          _-
 |   --__                  __--
 |       ----__________----
 ----------------------------------
  0              1               2
 
  The function return a float representing the slider fraction used to position the slider handle
  FractionFilled: this is the value slider position with no exponent
  StartFractionFilled: this is the neutral value slider position with no exponent
  SliderExponent: this is the slider exponent
*/
SLATE_API float SpinBoxComputeExponentSliderFraction(float FractionFilled, float StartFractionFilled, float SliderExponent);
 
template<typename NumericType>
class SSpinBox
    : public SCompoundWidget
{
public:
 
    DECLARE_DELEGATE_OneParam(FOnValueChanged, NumericType);
 
    DECLARE_DELEGATE_TwoParams(FOnValueCommitted, NumericType, ETextCommit::Type);
 
    DECLARE_DELEGATE_FourParams(FOnDynamicSliderMinMaxValueChanged, NumericType, TWeakPtr<SWidget>, bool, bool);
    
    DECLARE_DELEGATE_RetVal_OneParam(TOptional<FText>, FOnGetDisplayValue, NumericType);
 
    SLATE_BEGIN_ARGS(SSpinBox<NumericType>)
        : _Style(&FCoreStyle::Get().GetWidgetStyle<FSpinBoxStyle>("SpinBox"))
        , _Value(0)
        , _MinFractionalDigits(DefaultMinFractionalDigits)
        , _MaxFractionalDigits(DefaultMaxFractionalDigits)
        , _AlwaysUsesDeltaSnap(false)
        , _EnableSlider(true)
        , _Delta(0)
        , _ShiftMultiplier(10.f)
        , _CtrlMultiplier(0.1f)
        , _SupportDynamicSliderMaxValue(false)
        , _SupportDynamicSliderMinValue(false)
        , _SliderExponent(1.f)
        , _EnableWheel(true)
        , _BroadcastValueChangesPerKey(false)
        , _Font(FCoreStyle::Get().GetFontStyle(TEXT("NormalFont")))
        , _ContentPadding(FMargin(2.0f, 1.0f))
        , _OnValueChanged()
        , _OnValueCommitted()
        , _ClearKeyboardFocusOnCommit(false)
        , _SelectAllTextOnCommit(true)
        , _MinDesiredWidth(0.0f)
        , _Justification(ETextJustify::Left)
        , _KeyboardType(Keyboard_Default)
        , _PreventThrottling(true)
        , _RevertTextOnEscape(true)
    {}
 
    SLATE_STYLE_ARGUMENT(FSpinBoxStyle, Style)
 
        
        SLATE_ATTRIBUTE(NumericType, Value)
        SLATE_ATTRIBUTE(TOptional< NumericType >, MinValue)
        SLATE_ATTRIBUTE(TOptional< NumericType >, MaxValue)
        SLATE_ATTRIBUTE(TOptional< NumericType >, MinSliderValue)
        SLATE_ATTRIBUTE(TOptional< NumericType >, MaxSliderValue)
        SLATE_ATTRIBUTE(TOptional< int32 >, MinFractionalDigits)
        SLATE_ATTRIBUTE(TOptional< int32 >, MaxFractionalDigits)
        SLATE_ATTRIBUTE(bool, AlwaysUsesDeltaSnap)
        SLATE_ATTRIBUTE(bool, EnableSlider)
        SLATE_ATTRIBUTE(NumericType, Delta)
        SLATE_ATTRIBUTE_DEPRECATED(int32, ShiftMouseMovePixelPerDelta, 5.4, "Shift Mouse Move Pixel Per Delta is deprecated and incrementing by a fixed delta per pixel is no longer supported. Please use ShiftMultiplier and CtrlMultiplier which will multiply the step per mouse move")
        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(float, SliderExponent)
        SLATE_ATTRIBUTE(NumericType, SliderExponentNeutralValue)
        SLATE_ARGUMENT(bool, EnableWheel)
        SLATE_ARGUMENT(bool, BroadcastValueChangesPerKey)
        SLATE_ATTRIBUTE(TOptional< NumericType >, WheelStep)
        SLATE_ATTRIBUTE(FSlateFontInfo, Font)
        SLATE_ATTRIBUTE(FMargin, ContentPadding)
        SLATE_EVENT(FOnValueChanged, OnValueChanged)
        SLATE_EVENT(FOnValueCommitted, OnValueCommitted)
        SLATE_EVENT(FSimpleDelegate, OnBeginSliderMovement)
        SLATE_EVENT(FOnValueChanged, OnEndSliderMovement)
        SLATE_EVENT(FOnGetDisplayValue, OnGetDisplayValue)
        SLATE_EVENT(FOnGetDisplayValue, OnEditEditableText)
        SLATE_ATTRIBUTE(bool, ClearKeyboardFocusOnCommit)
        SLATE_ATTRIBUTE(bool, SelectAllTextOnCommit)
        SLATE_ATTRIBUTE(float, MinDesiredWidth)
        SLATE_ATTRIBUTE(ETextJustify::Type, Justification)
        SLATE_ATTRIBUTE(EKeyboardType, KeyboardType)
        SLATE_ATTRIBUTE(TSharedPtr< INumericTypeInterface<NumericType> >, TypeInterface)
        SLATE_ARGUMENT(bool, PreventThrottling)
        SLATE_ARGUMENT(bool, RevertTextOnEscape)
        SLATE_EVENT(FMenuExtensionDelegate, ContextMenuExtender)
 
    SLATE_END_ARGS()
 
    SLATE_API SSpinBox();
 
    SLATE_API virtual ~SSpinBox();
 
    SLATE_API void Construct(const FArguments& InArgs);
 
    SLATE_API virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
 
    SLATE_API void Tick(const FGeometry& AlottedGeometry, const double InCurrentTime, const float InDeltaTime);
 
    SLATE_API const bool CommitWithMultiplier(const FPointerEvent& MouseEvent);
 
    SLATE_API virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    SLATE_API virtual FReply OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    SLATE_API void ApplySliderMaxValueChanged(float SliderDeltaToAdd, bool UpdateOnlyIfHigher);
 
    SLATE_API void ApplySliderMinValueChanged(float SliderDeltaToAdd, bool UpdateOnlyIfLower);
 
    SLATE_API virtual FReply OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    SLATE_API virtual FReply OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    SLATE_API virtual FCursorReply OnCursorQuery(const FGeometry& MyGeometry, const FPointerEvent& CursorEvent) const override;
 
    SLATE_API virtual bool SupportsKeyboardFocus() const override;
 
 
    SLATE_API virtual FReply OnFocusReceived(const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent) override;
 
    SLATE_API virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
 
    SLATE_API virtual bool HasKeyboardFocus() const override;
 
    SLATE_API TAttribute<NumericType> GetValueAttribute() const;
 
    SLATE_API NumericType GetValue() const;
 
    SLATE_API void SetValue(const TAttribute<NumericType>& InValueAttribute, const bool bShouldCommit = false);
 
    SLATE_API NumericType GetMinValue() const;
 
    SLATE_API void SetMinValue(const TAttribute<TOptional<NumericType>>& InMinValue);
 
    SLATE_API NumericType GetMaxValue() const;
 
    SLATE_API void SetMaxValue(const TAttribute<TOptional<NumericType>>& InMaxValue);
 
    SLATE_API bool IsMinSliderValueBound() const;
 
    SLATE_API NumericType GetMinSliderValue() const;
 
    SLATE_API void SetMinSliderValue(const TAttribute<TOptional<NumericType>>& InMinSliderValue);
 
    SLATE_API bool IsMaxSliderValueBound() const;
 
    SLATE_API NumericType GetMaxSliderValue() const;
 
    SLATE_API void SetMaxSliderValue(const TAttribute<TOptional<NumericType>>& InMaxSliderValue);
 
    SLATE_API int32 GetMinFractionalDigits() const;
 
    SLATE_API void SetMinFractionalDigits(const TAttribute<TOptional<int32>>& InMinFractionalDigits);
 
    SLATE_API int32 GetMaxFractionalDigits() const;
 
    SLATE_API void SetMaxFractionalDigits(const TAttribute<TOptional<int32>>& InMaxFractionalDigits);
 
    SLATE_API bool GetAlwaysUsesDeltaSnap() const;
    SLATE_API void SetAlwaysUsesDeltaSnap(bool bNewValue);
 
    SLATE_API bool GetEnableSlider() const;
    SLATE_API void SetEnableSlider(bool bNewValue);
 
    SLATE_API NumericType GetDelta() const;
    SLATE_API void SetDelta(NumericType InDelta);
 
    SLATE_API float GetSliderExponent() const;
    SLATE_API void SetSliderExponent(const TAttribute<float>& InSliderExponent);
 
    SLATE_API float GetMinDesiredWidth() const;
    SLATE_API void SetMinDesiredWidth(const TAttribute<float>& InMinDesiredWidth);
 
    SLATE_API const FSpinBoxStyle* GetWidgetStyle() const;
    SLATE_API void SetWidgetStyle(const FSpinBoxStyle* InStyle);
    SLATE_API void InvalidateStyle();
 
    SLATE_API void SetTextBlockFont(FSlateFontInfo InFont);
    SLATE_API void SetTextJustification(ETextJustify::Type InJustification);
    SLATE_API void SetTextClearKeyboardFocusOnCommit(bool bNewValue);
    SLATE_API void SetTextRevertTextOnEscape(bool bNewValue);
    SLATE_API void SetTextSelectAllTextOnCommit(bool bNewValue);
 
    SLATE_API void ResetCachedValueString();
 
protected:
    SLATE_API void EnterTextMode();
 
    SLATE_API void ExitTextMode();
 
    SLATE_API FString GetValueAsString() const;
 
    SLATE_API FText GetValueAsText() const;
    
    SLATE_API FText GetDisplayValue() const;
 
    SLATE_API void TextField_OnTextChanged(const FText& NewText);
 
    SLATE_API void TextField_OnTextCommitted(const FText& NewText, ETextCommit::Type CommitInfo);
 
 
    enum ECommitMethod
    {
        CommittedViaSpin,
        CommittedViaTypeIn,
        CommittedViaArrowKey,
        CommittedViaCode,
        CommittedViaSpinMultiplier
    };
 
    SLATE_API void CommitValue(NumericType NewValue, double NewSpinValue, ECommitMethod CommitMethod, ETextCommit::Type OriginalCommitInfo, const bool bShouldCommit = false);
 
    SLATE_API void NotifyValueCommitted(NumericType CurrentValue) const;
 
    SLATE_API bool IsInTextMode() const;
 
    SLATE_API static float Fraction(double InValue, double InMinValue, double InMaxValue);
 
private:
    
    // New value to be Committed on Tick for MouseMove events
    // This exists to insulate high-frequency mouse move events which can fire many times during input processing
    // from the side-effects of committing the spinbox value
    struct FPendingCommitValue
    {
        double NewValue;
        ECommitMethod CommitMethod;
    };
 
    static constexpr int32 DefaultMinFractionalDigits = 1;
 
    static constexpr int32 DefaultMaxFractionalDigits = 6;
 
    TAttribute<NumericType> ValueAttribute;
    FOnValueChanged OnValueChanged;
    FOnValueCommitted OnValueCommitted;
    FSimpleDelegate OnBeginSliderMovement;
    FOnValueChanged OnEndSliderMovement;
    TSharedPtr<STextBlock> TextBlock;
    TSharedPtr<SEditableText> EditableText;
 
    TAttribute<TSharedPtr< INumericTypeInterface<NumericType> >> InterfaceAttr;
 
    bool bUnlimitedSpinRange;
    void UpdateIsSpinRangeUnlimited();
 
    const FSpinBoxStyle* Style;
 
    const FSlateBrush* BackgroundHoveredBrush;
    const FSlateBrush* BackgroundActiveBrush;
    const FSlateBrush* BackgroundBrush;
    const FSlateBrush* ActiveFillBrush;
    const FSlateBrush* HoveredFillBrush;
    const FSlateBrush* InactiveFillBrush;
 
    float DistanceDragged;
    TAttribute<NumericType> Delta;
    TAttribute<float> ShiftMultiplier;
    TAttribute<float> CtrlMultiplier;
    TAttribute<int32> LinearDeltaSensitivity;
    TAttribute<float> SliderExponent;
    TAttribute<NumericType> SliderExponentNeutralValue;
    TAttribute< TOptional<NumericType> > MinValue;
    TAttribute< TOptional<NumericType> > MaxValue;
    TAttribute< TOptional<NumericType> > MinSliderValue;
    TAttribute< TOptional<NumericType> > MaxSliderValue;
    TAttribute< TOptional<int32> > MinFractionalDigits;
    TAttribute< TOptional<int32> > MaxFractionalDigits;
    TAttribute<bool> AlwaysUsesDeltaSnap;
    TAttribute<bool> EnableSlider;
    TAttribute<bool> SupportDynamicSliderMaxValue;
    TAttribute<bool> SupportDynamicSliderMinValue;
    TAttribute< TOptional<NumericType> > WheelStep;
    FOnDynamicSliderMinMaxValueChanged OnDynamicSliderMaxValueChanged;
    FOnDynamicSliderMinMaxValueChanged OnDynamicSliderMinValueChanged;
    FOnGetDisplayValue OnGetDisplayValue;
    FOnGetDisplayValue OnEditEditableText;
 
    TAttribute<float> MinDesiredWidth;
    float GetTextMinDesiredWidth() const;
 
    bool IsCharacterValid(TCHAR InChar) const;
 
    NumericType RoundIfIntegerValue(double ValueToRound) const;
 
    void CancelMouseCapture();
 
    int32 PointerDraggingSliderIndex;
 
    FIntPoint CachedMousePosition;
 
    double InternalValue;
 
    NumericType PreDragValue;
 
    NumericType CachedExternalValue;
 
    FString CachedValueString;
 
    mutable bool bCachedValueStringDirty;
 
    bool bDragging;
 
    bool bIsTextChanging;
 
    /*
     * Holds whether or not to prevent throttling during mouse capture
     * When true, the viewport will be updated with every single change to the value during dragging
     */
    bool bPreventThrottling;
 
    bool bEnableWheel = true;
 
    bool bBroadcastValueChangesPerKey = false;
    
    TOptional<FPendingCommitValue> PendingCommitValue;
 
    /*
    * Gets the default amount to change the slider when delta is not applicable. 
    * Control takes priority over shift
    */
    double GetDefaultStepSize(const FInputEvent& InputEvent);
 
    const double StepSize = 1.f;
 
    const double SmallStepSize = .1f; 
 
    const double SmallStepSizeMax = 10.f;
};