SSlider.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 "Input/Reply.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "Framework/SlateDelegates.h"
#include "Widgets/SLeafWidget.h"
 
class FPaintArgs;
class FSlateWindowElementList;
 
class SSlider : public SLeafWidget
{
    SLATE_DECLARE_WIDGET_API(SSlider, SLeafWidget, SLATE_API)
 
public:
 
    SLATE_BEGIN_ARGS(SSlider)
        : _IndentHandle(true)
        , _MouseUsesStep(false)
        , _RequiresControllerLock(true)
        , _Locked(false)
        , _Orientation(EOrientation::Orient_Horizontal)
        , _SliderBarColor(FLinearColor::White)
        , _SliderHandleColor(FLinearColor::White)
        , _Style(&FCoreStyle::Get().GetWidgetStyle<FSliderStyle>("Slider"))
        , _StepSize(0.01f)
        , _Value(1.f)
        , _MinValue(0.0f)
        , _MaxValue(1.0f)
        , _IsFocusable(true)
        , _OnMouseCaptureBegin()
        , _OnMouseCaptureEnd()
        , _OnValueChanged()
        , _PreventThrottling(false)
        {
        }
 
        SLATE_ATTRIBUTE( bool, IndentHandle )
 
        
        SLATE_ARGUMENT( bool, MouseUsesStep )
 
        
        SLATE_ARGUMENT( bool, RequiresControllerLock )
 
        
        SLATE_ATTRIBUTE( bool, Locked )
 
        
        SLATE_ARGUMENT( EOrientation, Orientation)
 
        
        SLATE_ATTRIBUTE( FSlateColor, SliderBarColor )
 
        
        SLATE_ATTRIBUTE( FSlateColor, SliderHandleColor )
 
        
        SLATE_STYLE_ARGUMENT( FSliderStyle, Style )
 
        
        SLATE_ATTRIBUTE(float, StepSize)
 
        
        SLATE_ATTRIBUTE( float, Value )
 
        
        SLATE_ARGUMENT(float, MinValue)
        SLATE_ARGUMENT(float, MaxValue)
 
        
        SLATE_ARGUMENT(bool, IsFocusable)
 
        
        SLATE_EVENT(FSimpleDelegate, OnMouseCaptureBegin)
 
        
        SLATE_EVENT(FSimpleDelegate, OnMouseCaptureEnd)
 
        
        SLATE_EVENT(FSimpleDelegate, OnControllerCaptureBegin)
 
        
        SLATE_EVENT(FSimpleDelegate, OnControllerCaptureEnd)
 
        
        SLATE_EVENT( FOnFloatValueChanged, OnValueChanged )
 
        
        SLATE_ARGUMENT(bool, PreventThrottling)
 
    SLATE_END_ARGS()
 
    SLATE_API SSlider();
    SLATE_API virtual ~SSlider();
 
    SLATE_API void Construct( const SSlider::FArguments& InDeclaration );
 
    SLATE_API void SetStyle(const FSliderStyle* InStyle);
 
    float GetMinValue() const { return MinValue; }
 
    float GetMaxValue() const { return MaxValue; }
 
    SLATE_API float GetValue() const;
 
    SLATE_API float GetNormalizedValue() const;
 
    SLATE_API void SetValue(TAttribute<float> InValueAttribute);
 
    SLATE_API void SetMinAndMaxValues(float InMinValue, float InMaxValue);
    
    SLATE_API void SetIndentHandle(TAttribute<bool> InIndentHandle);
    
    SLATE_API void SetLocked(TAttribute<bool> InLocked);
 
    SLATE_API void SetOrientation(EOrientation InOrientation);
    
    SLATE_API void SetSliderBarColor(TAttribute<FSlateColor> InSliderBarColor);
    
    SLATE_API void SetSliderHandleColor(TAttribute<FSlateColor> InSliderHandleColor);
 
    SLATE_API float GetStepSize() const;
 
    SLATE_API void SetStepSize(TAttribute<float> InStepSize);
 
    SLATE_API void SetMouseUsesStep(bool MouseUsesStep);
 
    SLATE_API void SetRequiresControllerLock(bool RequiresControllerLock);
 
public:
 
    // SWidget overrides
 
    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 virtual FVector2D ComputeDesiredSize(float) const override;
    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 virtual void OnMouseCaptureLost(const FCaptureLostEvent& CaptureLostEvent) override;
    SLATE_API virtual FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnTouchStarted(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    SLATE_API virtual FReply OnTouchMoved(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    SLATE_API virtual FReply OnTouchEnded(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    SLATE_API virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
    SLATE_API virtual FReply OnKeyUp(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
    SLATE_API virtual void OnFocusLost(const FFocusEvent& InFocusEvent) override;
    SLATE_API virtual FNavigationReply OnNavigation(const FGeometry& MyGeometry, const FNavigationEvent& InNavigationEvent) override;
 
    SLATE_API virtual bool SupportsKeyboardFocus() const override;
    SLATE_API virtual bool IsInteractable() const override;
#if WITH_ACCESSIBILITY
    SLATE_API virtual TSharedRef<FSlateAccessibleWidget> CreateAccessibleWidget() override;
#endif
 
    SLATE_API bool IsLocked() const;
 
protected:
 
    SLATE_API virtual void CommitValue(float NewValue);
 
    SLATE_API float PositionToValue( const FGeometry& MyGeometry, const UE::Slate::FDeprecateVector2DParameter& AbsolutePosition );
 
    SLATE_API const FSlateBrush* GetBarImage() const;
    SLATE_API const FSlateBrush* GetThumbImage() const;
 
protected:
    TSlateAttributeRef<float> GetValueAttribute() const
    {
        return TSlateAttributeRef<float>(SharedThis(this), ValueSlateAttribute);
    }
 
    TSlateAttributeRef<bool> GetIndentHandleAttribute() const
    {
        return TSlateAttributeRef<bool>(SharedThis(this), IndentHandleSlateAttribute);
    }
 
    TSlateAttributeRef<bool> GetLockedAttribute() const
    {
        return TSlateAttributeRef<bool>(SharedThis(this), LockedSlateAttribute);
    }
 
    TSlateAttributeRef<FSlateColor> GetSliderBarColorAttribute() const
    {
        return TSlateAttributeRef<FSlateColor>(SharedThis(this), SliderBarColorSlateAttribute);
    }
 
    TSlateAttributeRef<FSlateColor> GetSliderHandleColorAttribute() const
    {
        return TSlateAttributeRef<FSlateColor>(SharedThis(this), SliderHandleColorSlateAttribute);
    }
 
    // Holds the style passed to the widget upon construction.
    const FSliderStyle* Style;
 
    // Holds the slider's orientation.
    EOrientation Orientation;
 
    // Holds the initial cursor in case a custom cursor has been specified, so we can restore it after dragging the slider
    EMouseCursor::Type CachedCursor;
 
    UE::Slate::FDeprecateVector2DResult PressedScreenSpaceTouchDownPosition;
 
    TAttribute<float> StepSize;
 
    float MinValue;
    float MaxValue;
 
    // 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;
 
    /*
     * 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 = false;
 
private:
 
    // Resets controller input state. Fires delegates.
    SLATE_API void ResetControllerState();
 
    // Holds the slider's current value.
    TSlateAttribute<float> ValueSlateAttribute;
 
    // Holds a flag indicating whether the slideable area should be indented to fit the handle.
    TSlateAttribute<bool> IndentHandleSlateAttribute;
 
    // Holds a flag indicating whether the slider is locked.
    TSlateAttribute<bool> LockedSlateAttribute;
 
    // Holds the color of the slider bar.
    TSlateAttribute<FSlateColor> SliderBarColorSlateAttribute;
 
    // Holds the color of the slider handle.
    TSlateAttribute<FSlateColor> SliderHandleColorSlateAttribute;
 
    // 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;
};