SRadialSlider.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Brushes/SlateRoundedBoxBrush.h"
#include "CoreMinimal.h"
#include "Curves/CurveFloat.h"
#include "Framework/SlateDelegates.h"
#include "Input/Reply.h"
#include "Misc/Attribute.h"
#include "Styling/CoreStyle.h"
#include "Styling/SlateBrush.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateTypes.h"
#include "Styling/SlateWidgetStyle.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Styling/StyleColors.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SLeafWidget.h"
 
class FPaintArgs;
class FSlateWindowElementList;
class UCurveFloat;
 
class SRadialSlider
    : public SLeafWidget
{
public:
 
    SLATE_BEGIN_ARGS(SRadialSlider)
        : _MouseUsesStep(false)
        , _RequiresControllerLock(true)
        , _Locked(false)
        , _SliderBarColor(FLinearColor::Gray)
        , _SliderProgressColor(FLinearColor::White)
        , _SliderHandleColor(FLinearColor::White)
        , _CenterBackgroundColor(FLinearColor::Transparent)
        , _CenterBackgroundBrush(FSlateRoundedBoxBrush(FStyleColors::Transparent, FVector2D(90.0f, 90.0f))) // todo: add to a custom radial slider style 
        , _Style(&FCoreStyle::Get().GetWidgetStyle<FSliderStyle>("Slider"))
        , _StepSize(0.01f)
        , _Value(1.f)
        , _bUseCustomDefaultValue(false)
        , _CustomDefaultValue(0.0f)
        , _SliderHandleStartAngle(60.0f)
        , _SliderHandleEndAngle(300.0f)
        , _AngularOffset(0.0f)
        , _HandStartEndRatio(FVector2D(0.0f, 1.0f))
        , _IsFocusable(true)
        , _UseVerticalDrag(false)
        , _ShowSliderHandle(true)
        , _ShowSliderHand(false)
        , _OnMouseCaptureBegin()
        , _OnMouseCaptureEnd()
        , _OnValueChanged()
        {
        }
 
    SLATE_ARGUMENT(bool, MouseUsesStep)
 
        
        SLATE_ARGUMENT(bool, RequiresControllerLock)
 
        
        SLATE_ATTRIBUTE(bool, Locked)
 
        
        SLATE_ATTRIBUTE(FSlateColor, SliderBarColor)
 
        
        SLATE_ATTRIBUTE(FSlateColor, SliderProgressColor)
 
        
        SLATE_ATTRIBUTE(FSlateColor, SliderHandleColor)
 
        
        SLATE_ATTRIBUTE(FSlateColor, CenterBackgroundColor)
 
        
        SLATE_ATTRIBUTE(float, Thickness)
 
        
        SLATE_ARGUMENT(FSlateBrush, CenterBackgroundBrush)
 
        
        SLATE_STYLE_ARGUMENT(FSliderStyle, Style )
 
        
        SLATE_ATTRIBUTE(float, StepSize)
 
        
        SLATE_ATTRIBUTE( float, Value )
 
        
        SLATE_ATTRIBUTE(bool, bUseCustomDefaultValue)
 
        
        SLATE_ATTRIBUTE(float, CustomDefaultValue)
 
        
        SLATE_ARGUMENT(FRuntimeFloatCurve, SliderRange)
 
        
        SLATE_ARGUMENT(float, SliderHandleStartAngle)
 
        
        SLATE_ARGUMENT(float, SliderHandleEndAngle)
 
        
        SLATE_ARGUMENT(float, AngularOffset)
 
        
        SLATE_ARGUMENT(FVector2D, HandStartEndRatio)
 
        
        SLATE_ARGUMENT(TArray<float>, ValueTags)
 
        
        SLATE_ARGUMENT(bool, IsFocusable)
 
        
        SLATE_ARGUMENT(bool, UseVerticalDrag)
 
        
        SLATE_ARGUMENT(bool, ShowSliderHandle)
 
        
        SLATE_ARGUMENT(bool, ShowSliderHand)
 
        
        SLATE_EVENT(FSimpleDelegate, OnMouseCaptureBegin)
 
        
        SLATE_EVENT(FSimpleDelegate, OnMouseCaptureEnd)
 
        
        SLATE_EVENT(FSimpleDelegate, OnControllerCaptureBegin)
 
        
        SLATE_EVENT(FSimpleDelegate, OnControllerCaptureEnd)
 
        
        SLATE_EVENT( FOnFloatValueChanged, OnValueChanged )
 
    SLATE_END_ARGS()
 
    ADVANCEDWIDGETS_API SRadialSlider();
    ADVANCEDWIDGETS_API virtual ~SRadialSlider();
 
    ADVANCEDWIDGETS_API void Construct( const SRadialSlider::FArguments& InDeclaration );
 
    FRuntimeFloatCurve GetSliderRange() const { return SliderRange; }
 
    ADVANCEDWIDGETS_API float GetMinValue() const;
 
    ADVANCEDWIDGETS_API float GetMaxValue() const;
 
    float GetSliderHandleStartAngle() const { return SliderHandleStartAngle; }
 
    float GetSliderHandleEndAngle() const { return SliderHandleEndAngle; }
 
    float GetAngularOffset() const { return AngularOffset; }
 
    TArray<float> GetValueTags() const { return ValueTags;  }
 
    ADVANCEDWIDGETS_API float GetValue() const;
 
    ADVANCEDWIDGETS_API bool GetUseCustomDefaultValue() const;
 
    ADVANCEDWIDGETS_API float GetCustomDefaultValue() const;
 
    ADVANCEDWIDGETS_API float GetNormalizedValue(float RawValue) const;
 
    ADVANCEDWIDGETS_API float GetNormalizedSliderHandlePosition() const;
 
    ADVANCEDWIDGETS_API void SetValue(const TAttribute<float>& InValueAttribute);
 
    ADVANCEDWIDGETS_API void SetUseCustomDefaultValue(const TAttribute<bool>& InValueAttribute);
 
    ADVANCEDWIDGETS_API void SetCustomDefaultValue(const TAttribute<float>& InValueAttribute);
    
    void SetSliderRange(const FRuntimeFloatCurve& InSliderRange) { SliderRange = InSliderRange; }
 
    ADVANCEDWIDGETS_API void SetSliderHandleStartAngleAndSliderHandleEndAngle(float InSliderHandleStartAngle, float InSliderHandleEndAngle);
    
    void SetAngularOffset(float InAngularOffset) { AngularOffset = InAngularOffset; }
 
    ADVANCEDWIDGETS_API void SetHandStartEndRatio(FVector2D InHandStartEndRatio);
 
    void SetValueTags(const TArray<float>& InValueTags) { ValueTags = InValueTags; }
 
    ADVANCEDWIDGETS_API void SetLocked(const TAttribute<bool>& InLocked);
    
    ADVANCEDWIDGETS_API void SetSliderBarColor(FSlateColor InSliderBarColor);
    
    ADVANCEDWIDGETS_API void SetSliderProgressColor(FSlateColor InSliderProgressColor);
 
    ADVANCEDWIDGETS_API void SetSliderHandleColor(FSlateColor InSliderHandleColor);
 
    ADVANCEDWIDGETS_API void SetCenterBackgroundColor(FSlateColor InCenterHandleColor);
 
    ADVANCEDWIDGETS_API void SetThickness(const float InThickness);
 
    ADVANCEDWIDGETS_API float GetStepSize() const;
 
    ADVANCEDWIDGETS_API void SetStepSize(const TAttribute<float>& InStepSize);
 
    ADVANCEDWIDGETS_API void SetMouseUsesStep(bool MouseUsesStep);
 
    ADVANCEDWIDGETS_API void SetRequiresControllerLock(bool RequiresControllerLock);
 
    ADVANCEDWIDGETS_API void SetUseVerticalDrag(bool UseVerticalDrag);
 
    ADVANCEDWIDGETS_API void SetShowSliderHandle(bool ShowSliderHandle);
 
    ADVANCEDWIDGETS_API void SetShowSliderHand(bool ShowSliderHand);
 
public:
 
    // SWidget overrides
 
    ADVANCEDWIDGETS_API virtual int32 OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const override;
    ADVANCEDWIDGETS_API virtual FVector2D ComputeDesiredSize(float) const override;
    ADVANCEDWIDGETS_API virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    ADVANCEDWIDGETS_API virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    ADVANCEDWIDGETS_API virtual FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    ADVANCEDWIDGETS_API virtual FReply OnTouchStarted(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    ADVANCEDWIDGETS_API virtual FReply OnTouchMoved(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    ADVANCEDWIDGETS_API virtual FReply OnTouchEnded(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    ADVANCEDWIDGETS_API virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
    ADVANCEDWIDGETS_API virtual FReply OnKeyUp(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
    ADVANCEDWIDGETS_API virtual void OnFocusLost(const FFocusEvent& InFocusEvent) override;
    ADVANCEDWIDGETS_API virtual FNavigationReply OnNavigation(const FGeometry& MyGeometry, const FNavigationEvent& InNavigationEvent) override;
 
    ADVANCEDWIDGETS_API virtual bool SupportsKeyboardFocus() const override;
    ADVANCEDWIDGETS_API virtual bool IsInteractable() const override;
#if WITH_ACCESSIBILITY
    ADVANCEDWIDGETS_API virtual TSharedRef<FSlateAccessibleWidget> CreateAccessibleWidget() override;
#endif
 
    ADVANCEDWIDGETS_API bool IsLocked() const;
 
protected:
 
    ADVANCEDWIDGETS_API virtual void CommitValue(float NewValue);
 
    ADVANCEDWIDGETS_API float PositionToValue(const FGeometry& MyGeometry, const FVector2D& AbsolutePosition);
    
    ADVANCEDWIDGETS_API const FSlateBrush* GetBarImage() const;
    ADVANCEDWIDGETS_API const FSlateBrush* GetThumbImage() const;
 
protected:
 
    // Holds the style passed to the widget upon construction.
    const FSliderStyle* Style;
 
    // Holds a flag indicating whether the slider is locked.
    TAttribute<bool> LockedAttribute;
 
    // Holds the color of the slider bar.
    TAttribute<FSlateColor> SliderBarColor;
 
    // Holds the color for the completed progress of the slider bar.
    TAttribute<FSlateColor> SliderProgressColor;
 
    // Holds the color of the slider handle.
    TAttribute<FSlateColor> SliderHandleColor;
 
    // Holds the color of the center background.
    TAttribute<FSlateColor> CenterBackgroundColor;
 
    // Center background image brush
    FSlateBrush CenterBackgroundBrush;
 
    // Thickness used for slider bar instead of Style->BarThickness (see SetThickness)
    TAttribute<TOptional<float>> Thickness;
 
    // Holds the slider's current value.
    TAttribute<float> ValueAttribute;
 
    // Whether the slider should draw it's progress bar from a custom value on the slider
    TAttribute<bool> bUseCustomDefaultValue;
 
    // The value where the slider should draw it's progress bar from, independent of direction
    TAttribute<float> CustomDefaultValue;
 
    // Holds the initial cursor in case a custom cursor has been specified, so we can restore it after dragging the slider
    EMouseCursor::Type CachedCursor;
 
    FVector2D PressedScreenSpaceTouchDownPosition = FVector2D(0, 0);
 
    TAttribute<float> StepSize;
 
    float SliderHandleStartAngle;
 
    float SliderHandleEndAngle;
 
    float AngularOffset;
 
    FVector2D HandStartEndRatio;
 
    TArray<float> ValueTags;
 
    FRuntimeFloatCurve SliderRange;
 
    // Holds a flag indicating whether a controller/keyboard is manipulating the slider's value. 
    // When true, navigation away from the widget is prevented until a new value has been accepted or canceled. 
    bool bControllerInputCaptured;
 
    bool bMouseUsesStep;
 
    bool bRequiresControllerLock;
 
    bool bIsFocusable;
 
    bool bUseVerticalDrag;
 
    bool bShowSliderHandle;
 
    bool bShowSliderHand;
 
private:
 
    // Resets controller input state. Fires delegates.
    ADVANCEDWIDGETS_API void ResetControllerState();
 
    // Helper function to convert Absolute Position to Angle
    ADVANCEDWIDGETS_API float GetAngleFromPosition(const FGeometry& MyGeometry, const FVector2D& AbsolutePosition);
    
    // Called on Mouse / Touch input to cache relevant properties
    ADVANCEDWIDGETS_API void OnInputStarted(const FGeometry& MyGeometry, const FVector2D& InputAbsolutePosition);
 
    // Helper function for adding slider points to a slider points array
    ADVANCEDWIDGETS_API void AddSliderPointToArray(TArray<FVector2D>& SliderPoints, const bool bIsUnique, const FVector2D& SliderPoint) const;
 
    // Holds a delegate that is executed when the mouse is pressed and a capture begins.
    FSimpleDelegate OnMouseCaptureBegin;
 
    // Holds a delegate that is executed when the mouse is let up and a capture ends.
    FSimpleDelegate OnMouseCaptureEnd;
 
    // Holds a delegate that is executed when capture begins for controller or keyboard.
    FSimpleDelegate OnControllerCaptureBegin;
 
    // Holds a delegate that is executed when capture ends for controller or keyboard.
    FSimpleDelegate OnControllerCaptureEnd;
 
    // Holds a delegate that is executed when the slider's value changed.
    FOnFloatValueChanged OnValueChanged;
 
    // Holds the current interaction's unclamped input angle.
    float AbsoluteInputAngle;
 
    // Stores the previous absolute position to support calculating rotational delta for relative input
    FVector2D PreviousAbsolutePosition;
 
    // Settings for behavior when IsUsingVerticalDrag is true
    // For when UseVerticalDrag is true, whether we're fine tuning the value 
    bool bIsUsingFineTune;
 
    // The key to use when fine tuning vertical drag 
    FKey FineTuneKey;
 
    float VerticalDragMouseSpeedNormal = 0.2f;
    float VerticalDragMouseSpeedFineTune = 0.05f;
    float VerticalDragPixelDelta = 50.0f;
};