SColorGradingComponentSpinBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Framework/ColorGrading/ColorGradingCommon.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "InputCoreTypes.h"
#include "HAL/Platform.h"
#include "Misc/Attribute.h"
#include "Styling/AdvancedWidgetsStyle.h"
#include "Styling/ColorGradingSpinBoxStyle.h"
#include "Styling/CoreStyle.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/Input/NumericTypeInterface.h"
#include "Widgets/Input/SSpinBox.h"
#include "Widgets/SCompoundWidget.h"
 
namespace UE::ColorGrading
{
 
class SColorGradingComponentSpinBox
    : public SCompoundWidget
{
public:
 
    DECLARE_DELEGATE_OneParam(FOnValueChanged, float);
 
    DECLARE_DELEGATE_FourParams(FOnDynamicSliderMinMaxValueChanged, float, TWeakPtr<SWidget>, bool, bool);
 
    SLATE_BEGIN_ARGS(SColorGradingComponentSpinBox)
        : _Style(&UE::AdvancedWidgets::FAdvancedWidgetsStyle::Get().GetWidgetStyle<FColorGradingSpinBoxStyle>("ColorGradingSpinBox"))
        , _Value(0)
        , _Component(EColorGradingComponent::Red)
        , _ColorGradingMode(EColorGradingModes::Invalid)
        , _MinValue(0)
        , _MaxValue(2)
        , _Delta(0)
        , _ShiftMultiplier(10.f)
        , _CtrlMultiplier(0.1f)
        , _Sensitivity(1.0f)
        , _SupportDynamicSliderMaxValue(false)
        , _SupportDynamicSliderMinValue(false)
        , _SliderExponent(1.f)
        , _OnValueChanged()
        , _OnQueryCurrentColor()
        , _AllowSpin(true)
        {}
 
        SLATE_STYLE_ARGUMENT(FColorGradingSpinBoxStyle, Style)
 
        
        SLATE_ATTRIBUTE(float, Value)
        SLATE_ATTRIBUTE(EColorGradingComponent, Component)
        SLATE_ATTRIBUTE(EColorGradingModes, ColorGradingMode)
        SLATE_ATTRIBUTE(TOptional<float>, MinValue)
        SLATE_ATTRIBUTE(TOptional<float>, MaxValue)
        SLATE_ATTRIBUTE(TOptional<float>, MinSliderValue)
        SLATE_ATTRIBUTE(TOptional<float>, MaxSliderValue)
        SLATE_ATTRIBUTE(bool, AlwaysUsesDeltaSnap)
        SLATE_ATTRIBUTE(float, Delta)
        SLATE_ATTRIBUTE(float, ShiftMultiplier)
        SLATE_ATTRIBUTE(float, CtrlMultiplier)
        SLATE_ATTRIBUTE(float, Sensitivity)
        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(float, SliderExponentNeutralValue)
        SLATE_ATTRIBUTE(TOptional<float>, WheelStep)
        SLATE_EVENT(FOnValueChanged, OnValueChanged)
        SLATE_EVENT(FSimpleDelegate, OnBeginSliderMovement)
        SLATE_EVENT(FOnValueChanged, OnEndSliderMovement)
        SLATE_EVENT(FOnGetCurrentVector4Value, OnQueryCurrentColor)
        SLATE_ARGUMENT(TSharedPtr<INumericTypeInterface<float>>, TypeInterface)
        SLATE_ARGUMENT(bool, AllowSpin)
 
    SLATE_END_ARGS()
 
    SColorGradingComponentSpinBox() = default;
 
    virtual ~SColorGradingComponentSpinBox();
 
    void Construct(const FArguments& InArgs);
 
    virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
 
    const bool CommitWithMultiplier(const FPointerEvent& MouseEvent);
 
    virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    virtual FReply OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    void ApplySliderMaxValueChanged(float SliderDeltaToAdd, bool UpdateOnlyIfHigher);
 
    void ApplySliderMinValueChanged(float SliderDeltaToAdd, bool UpdateOnlyIfLower);
 
    virtual FReply OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    virtual FCursorReply OnCursorQuery(const FGeometry& MyGeometry, const FPointerEvent& CursorEvent) const override;
 
    TAttribute<float> GetValueAttribute() const { return ValueAttribute; }
 
    float GetValue() const { return ValueAttribute.Get(); }
    void SetValue(const TAttribute<float>& InValueAttribute)
    {
        ValueAttribute = InValueAttribute;
        const float LocalValueAttribute = ValueAttribute.Get();
        CommitValue(LocalValueAttribute, (double)LocalValueAttribute, ECommitMethod::CommittedViaCode, ETextCommit::Default);
    }
 
    float GetMinValue() const { return MinValue.Get().Get(std::numeric_limits<float>::lowest()); }
    void SetMinValue(const TAttribute<TOptional<float>>& InMinValue)
    {
        MinValue = InMinValue;
        UpdateIsSpinRangeUnlimited();
    }
 
    float GetMaxValue() const { return MaxValue.Get().Get(std::numeric_limits<float>::max()); }
    void SetMaxValue(const TAttribute<TOptional<float>>& InMaxValue)
    {
        MaxValue = InMaxValue;
        UpdateIsSpinRangeUnlimited();
    }
 
    bool IsMinSliderValueBound() const { return MinSliderValue.IsBound(); }
 
    float GetMinSliderValue() const { return MinSliderValue.Get().Get(std::numeric_limits<float>::lowest()); }
    void SetMinSliderValue(const TAttribute<TOptional<float>>& InMinSliderValue)
    {
        MinSliderValue = (InMinSliderValue.Get().IsSet()) ? InMinSliderValue : MinValue;
        UpdateIsSpinRangeUnlimited();
    }
 
    bool IsMaxSliderValueBound() const { return MaxSliderValue.IsBound(); }
 
    float GetMaxSliderValue() const { return MaxSliderValue.Get().Get(std::numeric_limits<float>::max()); }
    void SetMaxSliderValue(const TAttribute<TOptional<float>>& InMaxSliderValue)
    {
        MaxSliderValue = (InMaxSliderValue.Get().IsSet()) ? InMaxSliderValue : MaxValue;;
        UpdateIsSpinRangeUnlimited();
    }
 
    bool GetAlwaysUsesDeltaSnap() const { return AlwaysUsesDeltaSnap.Get(); }
    void SetAlwaysUsesDeltaSnap(bool bNewValue) { AlwaysUsesDeltaSnap.Set(bNewValue); }
 
    float GetDelta() const { return Delta.Get(); }
    void SetDelta(float InDelta) { Delta.Set(InDelta); }
 
    float GetSliderExponent() const { return SliderExponent.Get(); }
    void SetSliderExponent(const TAttribute<float>& InSliderExponent) { SliderExponent = InSliderExponent; }
 
    const FColorGradingSpinBoxStyle* GetWidgetStyle() const { return Style; }
    void SetWidgetStyle(const FColorGradingSpinBoxStyle* InStyle) { Style = InStyle; }
    void InvalidateStyle() { Invalidate(EInvalidateWidgetReason::Layout); }
 
protected:
    enum ECommitMethod
    {
        CommittedViaSpin,
        CommittedViaCode,
        CommittedViaSpinMultiplier
    };
 
    void CommitValue(float NewValue, double NewSpinValue, ECommitMethod CommitMethod, ETextCommit::Type OriginalCommitInfo);
 
    void NotifyValueCommitted(float CurrentValue) const;
 
    static float Fraction(double InValue, double InMinValue, double InMaxValue);
 
private:
 
    static const TArray<FLinearColor>& GetHueGradientColors();
    static TArray<FLinearColor> HueGradientColors;
 
    TAttribute<float> ValueAttribute;
    FOnValueChanged OnValueChanged;
    FSimpleDelegate OnBeginSliderMovement;
    FOnValueChanged OnEndSliderMovement;
    FOnGetCurrentVector4Value OnQueryCurrentColor;
 
    TSharedPtr<INumericTypeInterface<float>> Interface;
 
    bool bUnlimitedSpinRange;
    void UpdateIsSpinRangeUnlimited()
    {
        bUnlimitedSpinRange = !((MinValue.Get().IsSet() && MaxValue.Get().IsSet()) || (MinSliderValue.Get().IsSet() && MaxSliderValue.Get().IsSet()));
    }
 
    const FColorGradingSpinBoxStyle* Style;
 
    const FSlateBrush* BorderHoveredBrush;
    const FSlateBrush* BorderActiveBrush;
    const FSlateBrush* BorderBrush;
    const FSlateBrush* SelectorBrush;
    const float* SelectorWidth;
 
    bool bAllowSpin;
    float DistanceDragged;
    TAttribute<float> Delta;
    TAttribute<float> ShiftMultiplier;
    TAttribute<float> CtrlMultiplier;
    TAttribute<float> Sensitivity;
    TAttribute<int32> LinearDeltaSensitivity;
    TAttribute<float> SliderExponent;
    TAttribute<float> SliderExponentNeutralValue;
    TAttribute<TOptional<float>> MinValue;
    TAttribute<TOptional<float>> MaxValue;
    TAttribute<TOptional<float>> MinSliderValue;
    TAttribute<TOptional<float>> MaxSliderValue;
    TAttribute<bool> AlwaysUsesDeltaSnap;
    TAttribute<bool> SupportDynamicSliderMaxValue;
    TAttribute<bool> SupportDynamicSliderMinValue;
    FOnDynamicSliderMinMaxValueChanged OnDynamicSliderMaxValueChanged;
    FOnDynamicSliderMinMaxValueChanged OnDynamicSliderMinValueChanged;
    TAttribute<EColorGradingComponent> Component;
    TAttribute<EColorGradingModes> ColorGradingMode;
 
    float RoundIfIntegerValue(double ValueToRound) const;
 
    void CancelMouseCapture();
 
    TArray<FLinearColor> GetGradientColors() const;
 
    FLinearColor GetCurrentRGBColor() const;
 
    FLinearColor GetCurrentHSVColor() const;
 
    int32 PointerDraggingSliderIndex;
 
    FIntPoint CachedMousePosition;
 
    double InternalValue;
 
    float PreDragValue;
 
    float CachedExternalValue;
 
    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;
};
 
} //namespace