SScrollBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Layout/Visibility.h"
#include "SlotBase.h"
#include "Layout/Geometry.h"
#include "Styling/SlateColor.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "Input/NavigationReply.h"
#include "Widgets/SWidget.h"
#include "Widgets/SPanel.h"
#include "Widgets/SBoxPanel.h"
#include "Layout/Children.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SCompoundWidget.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "Widgets/Layout/SScrollBar.h"
#include "Framework/Layout/InertialScrollManager.h"
#include "Framework/Layout/Overscroll.h"
 
#include "SScrollBox.generated.h"
 
class FPaintArgs;
class FSlateWindowElementList;
class SScrollPanel;
 
DECLARE_DELEGATE(FOnScrollBoxFocusReceived);
DECLARE_DELEGATE(FOnScrollBoxFocusLost);
 
 
UENUM(BlueprintType)
enum class EDescendantScrollDestination : uint8
{
    IntoView,
 
    TopOrLeft,
 
    Center,
 
    BottomOrRight,
};
 
UENUM(BlueprintType)
enum class EScrollWhenFocusChanges : uint8
{
    NoScroll,
 
    InstantScroll,
 
    AnimatedScroll,
};
 
class SScrollBox : public SCompoundWidget
{
public:
    class FSlot : public TBasicLayoutWidgetSlot<FSlot>, public TResizingWidgetSlotMixin<FSlot>
    {
    public:
        SLATE_SLOT_BEGIN_ARGS_OneMixin(FSlot, TBasicLayoutWidgetSlot<FSlot>, TResizingWidgetSlotMixin<FSlot>)
            FSlotArguments& AutoSize()
            {
                _SizeParam = FAuto();
                return Me();
            }
 
            FSlotArguments& FillSize(TAttribute<float> InStretchCoefficient)
            {
                _SizeParam = FStretch(MoveTemp(InStretchCoefficient));
                return Me();
            }
 
            FSlotArguments& FillContentSize(TAttribute<float> InStretchCoefficient, TAttribute<float> InShrinkStretchCoefficient = TAttribute<float>())
            {
                _SizeParam = FStretchContent(MoveTemp(InStretchCoefficient), MoveTemp(InShrinkStretchCoefficient));
                return Me();
            }
 
            FSlotArguments& MinSize(TAttribute<float> InMinHeight)
            {
                _MinSize = MoveTemp(InMinHeight);
                return Me();
            }
 
            FSlotArguments& MaxSize(TAttribute<float> InMaxHeight)
            {
                _MaxSize = MoveTemp(InMaxHeight);
                return Me();
            }
        SLATE_SLOT_END_ARGS()
 
        
        FSlot()
            : TBasicLayoutWidgetSlot<FSlot>(HAlign_Fill, VAlign_Fill)
            , TResizingWidgetSlotMixin<SScrollBox::FSlot>()
        {
            this->SizeRule = FSizeParam::SizeRule_Auto;
        }
 
        SLATE_API void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs);
        static SLATE_API void RegisterAttributes(FSlateWidgetSlotAttributeInitializer& AttributeInitializer);
 
    private:
        bool bIsShrinkSizeValueSet;
    };
 
    SLATE_BEGIN_ARGS(SScrollBox)
        : _Style( &FAppStyle::Get().GetWidgetStyle<FScrollBoxStyle>("ScrollBox") )
        , _ScrollBarStyle( &FAppStyle::Get().GetWidgetStyle<FScrollBarStyle>("ScrollBar") )
        , _ExternalScrollbar()
        , _Orientation(Orient_Vertical)
        , _ScrollBarVisibility(EVisibility::Visible)
        , _ScrollBarAlwaysVisible(false)
        , _ScrollBarDragFocusCause(EFocusCause::Mouse)
        , _ScrollBarThickness(FVector2f(_Style->BarThickness, _Style->BarThickness))
        , _ScrollBarPadding(2.0f)
        , _AllowOverscroll(EAllowOverscroll::Yes)
        , _BackPadScrolling(false)
        , _FrontPadScrolling(false)
        , _AnimateWheelScrolling(false)
        , _ScrollAnimationInterpSpeed(15.f)
        , _WheelScrollMultiplier(1.f)
        , _EnableTouchScrolling(true)
        , _ConsumePointerInput (true)
        , _NavigationDestination(EDescendantScrollDestination::IntoView)
        , _NavigationScrollPadding(0.0f)
        , _ScrollWhenFocusChanges(EScrollWhenFocusChanges::NoScroll)
        , _OnUserScrolled()
        , _OnScrollBarVisibilityChanged()
        , _OnFocusReceived()
        , _OnFocusLost()
        , _ConsumeMouseWheel(EConsumeMouseWheel::WhenScrollingPossible)
        , _AllowContentToShrink(false)
        {
            _Clipping = EWidgetClipping::ClipToBounds;
        }
        
        SLATE_SLOT_ARGUMENT( FSlot, Slots )
 
        
        SLATE_STYLE_ARGUMENT( FScrollBoxStyle, Style )
 
        
        SLATE_STYLE_ARGUMENT( FScrollBarStyle, ScrollBarStyle )
 
        
        SLATE_ARGUMENT( TSharedPtr<SScrollBar>, ExternalScrollbar )
 
        
        SLATE_ARGUMENT( EOrientation, Orientation )
 
        SLATE_ARGUMENT( EVisibility, ScrollBarVisibility )
 
        SLATE_ARGUMENT( bool, ScrollBarAlwaysVisible )
 
        SLATE_ARGUMENT( EFocusCause, ScrollBarDragFocusCause )
 
        SLATE_ARGUMENT( UE::Slate::FDeprecateVector2DParameter, ScrollBarThickness )
 
        
        SLATE_ARGUMENT( FMargin, ScrollBarPadding )
 
        SLATE_ARGUMENT(EAllowOverscroll, AllowOverscroll);
 
        SLATE_ARGUMENT(bool, BackPadScrolling);
 
        SLATE_ARGUMENT(bool, FrontPadScrolling);
 
        SLATE_ARGUMENT(bool, AnimateWheelScrolling);
 
        SLATE_ARGUMENT(float, ScrollAnimationInterpSpeed);
 
        SLATE_ARGUMENT(float, WheelScrollMultiplier);
 
        SLATE_ARGUMENT(bool, EnableTouchScrolling);
        
        SLATE_ARGUMENT(bool, ConsumePointerInput );
 
        SLATE_ARGUMENT(EDescendantScrollDestination, NavigationDestination);
 
        SLATE_ARGUMENT(float, NavigationScrollPadding);
 
        SLATE_ARGUMENT(EScrollWhenFocusChanges, ScrollWhenFocusChanges);
 
        SLATE_EVENT(FOnUserScrolled, OnUserScrolled)
 
        SLATE_EVENT(FOnScrollBarVisibilityChanged, OnScrollBarVisibilityChanged)
 
        SLATE_EVENT(FOnScrollBoxFocusReceived, OnFocusReceived)
        
        SLATE_EVENT(FOnScrollBoxFocusLost, OnFocusLost)
 
        SLATE_ARGUMENT(EConsumeMouseWheel, ConsumeMouseWheel);
 
        SLATE_ARGUMENT(bool, AllowContentToShrink);
 
    SLATE_END_ARGS()
 
    SLATE_API SScrollBox();
    SLATE_API virtual ~SScrollBox();
 
    static SLATE_API FSlot::FSlotArguments Slot();
 
    SLATE_API void Construct( const FArguments& InArgs );
 
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    SLATE_API FScopedWidgetSlotArguments AddSlot();
 
    SLATE_API FScopedWidgetSlotArguments InsertSlot(int32 Index);
 
    SLATE_API const FSlot& GetSlot(int32 SlotIndex) const;
    SLATE_API FSlot& GetSlot(int32 SlotIndex);
 
    SLATE_API void RemoveSlot(const TSharedRef<SWidget>& WidgetToRemove);
 
    SLATE_API int32 NumSlots() const;
 
    SLATE_API void ClearChildren();
 
    SLATE_API bool IsRightClickScrolling() const;
 
    SLATE_API EAllowOverscroll GetAllowOverscroll() const;
 
    SLATE_API void SetAllowOverscroll( EAllowOverscroll NewAllowOverscroll );
 
    SLATE_API void SetAnimateWheelScrolling(bool bInAnimateWheelScrolling);
 
    SLATE_API void SetScrollingAnimationInterpolationSpeed(float NewScrollingAnimationInterpolationSpeed);
 
    SLATE_API void SetWheelScrollMultiplier(float NewWheelScrollMultiplier);
 
    SLATE_API void SetIsTouchScrollingEnabled(const bool bInEnableTouchScrolling);
    
    void SetConsumePointerInput(bool bInConsumePointerInput) { bConsumePointerInput = bInConsumePointerInput; }
    
    SLATE_API void SetScrollWhenFocusChanges(EScrollWhenFocusChanges NewScrollWhenFocusChanges);
 
    SLATE_API float GetScrollOffset() const;
 
    SLATE_API UE::Slate::FDeprecateVector2DResult GetScrollPanelContentSize() const;
    
    SLATE_API float GetOverscrollOffset() const;
    
    SLATE_API float GetOverscrollPercentage() const;
    
    SLATE_API float GetViewFraction() const;
 
    SLATE_API float GetViewOffsetFraction() const;
 
    SLATE_API float GetScrollOffsetOfEnd() const;
 
    bool GetIsScrolling() const { return bIsScrolling; }
 
    SLATE_API void SetScrollOffset( float NewScrollOffset );
 
    SLATE_API void ScrollToStart();
 
    SLATE_API void ScrollToEnd();
 
    SLATE_API void EndInertialScrolling();
 
    SLATE_API void ScrollDescendantIntoView(const TSharedPtr<SWidget>& WidgetToFind, bool InAnimateScroll = true, EDescendantScrollDestination InDestination = EDescendantScrollDestination::IntoView, float Padding = 0);
 
    SLATE_API EOrientation GetOrientation();
 
    SLATE_API void SetNavigationDestination(const EDescendantScrollDestination NewNavigationDestination);
 
    SLATE_API void SetConsumeMouseWheel(EConsumeMouseWheel NewConsumeMouseWheel);
 
    SLATE_API void SetAnalogMouseWheelKey(FKey InAnalogKey);
 
    SLATE_API void SetIsFocusable(bool bInIsFocusable);
 
    SLATE_API void SetOrientation(EOrientation InOrientation);
 
    SLATE_API void SetScrollBarVisibility(EVisibility InVisibility);
 
    SLATE_API void SetScrollBarAlwaysVisible(bool InAlwaysVisible);
    
    SLATE_API void SetScrollBarTrackAlwaysVisible(bool InAlwaysVisible);
 
    SLATE_API void SetScrollBarThickness(UE::Slate::FDeprecateVector2DParameter InThickness);
 
    SLATE_API void SetScrollBarPadding(const FMargin& InPadding);
 
    SLATE_API void SetScrollBarRightClickDragAllowed(bool bIsAllowed);
 
    SLATE_API void SetStyle(const FScrollBoxStyle* InStyle);
    
    SLATE_API void SetScrollBarStyle(const FScrollBarStyle* InBarStyle);
 
    SLATE_API void InvalidateStyle();
 
    SLATE_API void InvalidateScrollBarStyle();
 
public:
 
    // SWidget interface
    SLATE_API virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) override;
    SLATE_API virtual bool ComputeVolatility() const override;
    SLATE_API virtual FReply OnPreviewMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) 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 FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual void OnMouseEnter( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual void OnMouseLeave( const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnMouseWheel( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnAnalogValueChanged( const FGeometry& MyGeometry, const FAnalogInputEvent& InAnalogInputEvent) override;
    SLATE_API virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) const override;
    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 FReply OnTouchEnded(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent) override;
    SLATE_API virtual void OnMouseCaptureLost(const FCaptureLostEvent& CaptureLostEvent) override;
    SLATE_API virtual FNavigationReply OnNavigation(const FGeometry& MyGeometry, const FNavigationEvent& InNavigationEvent) override;
    SLATE_API virtual void OnFocusChanging(const FWeakWidgetPath& PreviousFocusPath, const FWidgetPath& NewWidgetPath, const FFocusEvent& InFocusEvent) override;
    SLATE_API virtual FReply OnFocusReceived(const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent) override;
    SLATE_API virtual void OnFocusLost(const FFocusEvent& InFocusEvent) override;
    virtual bool SupportsKeyboardFocus() const override { return bIsFocusable; }
    // End of SWidget interface
 
protected:
    SLATE_API void OnClippingChanged();
 
private:
 
    TSharedPtr<SScrollBar> ConstructScrollBar();
 
    void ConstructVerticalLayout();
 
    void ConstructHorizontalLayout();
 
    inline float GetScrollComponentFromVector(FVector2f Vector) const
    {
        return float(Orientation == Orient_Vertical ? Vector.Y : Vector.X);
    }
 
    inline void SetScrollComponentOnVector(FVector2f& InVector, float Value) const
    {
        if (Orientation == Orient_Vertical)
        {
            InVector.Y = Value;
        }
        else
        {
            InVector.X = Value;
        }
    }
 
    float DesiredScrollOffset;
 
    bool ScrollBy(const FGeometry& AllottedGeometry, float LocalScrollAmount, EAllowOverscroll Overscroll, bool InAnimateScroll);
 
    void ScrollBar_OnUserScrolled( float InScrollOffsetFraction );
 
    void ScrollBar_OnScrollBarVisibilityChanged( EVisibility NewVisibility);
 
    FSlateColor GetStartShadowOpacity() const;
    
    FSlateColor GetEndShadowOpacity() const;
 
    EActiveTimerReturnType UpdateInertialScroll(double InCurrentTime, float InDeltaTime);
 
    bool CanUseInertialScroll(float ScrollAmount) const;
 
    void BeginInertialScrolling();
 
    FMargin ScrollBarSlotPadding;
 
    union
    {
        // vertical scroll bar is stored in horizontal box and vice versa
        SHorizontalBox::FSlot* VerticalScrollBarSlot; // valid when Orientation == Orient_Vertical
        SVerticalBox::FSlot* HorizontalScrollBarSlot; // valid when Orientation == Orient_Horizontal
    };
 
protected:
    SLATE_API bool InternalScrollDescendantIntoView(const FGeometry& MyGeometry, const TSharedPtr<SWidget>& WidgetToFind, bool InAnimateScroll = true, EDescendantScrollDestination InDestination = EDescendantScrollDestination::IntoView, float Padding = 0);
 
    SLATE_API TSharedPtr<SWidget> GetKeyboardFocusableWidget(TSharedPtr<SWidget> InWidget);
 
    TSharedPtr<class SScrollPanel> ScrollPanel;
 
    TSharedPtr<SScrollBar> ScrollBar;
 
    float TickScrollDelta;
 
    TOptional<int32> bFingerOwningTouchInteraction;
 
    float AmountScrolledWhileRightMouseDown;
 
    float PendingScrollTriggerAmount;
 
    FInertialScrollManager InertialScrollManager;
 
    FOverscroll Overscroll;
 
    EAllowOverscroll AllowOverscroll;
 
    bool BackPadScrolling;
 
    bool FrontPadScrolling;
 
    float NavigationScrollPadding;
 
    EDescendantScrollDestination NavigationDestination;
 
    EScrollWhenFocusChanges ScrollWhenFocusChanges;
 
    FVector2f SoftwareCursorPosition;
 
    FOnUserScrolled OnUserScrolled;
    
    FOnScrollBarVisibilityChanged OnScrollBarVisibilityChanged;
 
    FOnScrollBoxFocusReceived OnScrollBoxFocusReceived;
        
    FOnScrollBoxFocusLost OnScrollBoxFocusLost;
 
    EOrientation Orientation;
 
    const FScrollBoxStyle* Style;
 
    const FScrollBarStyle* ScrollBarStyle;
 
    EConsumeMouseWheel ConsumeMouseWheel;
 
    FKey AnalogMouseWheelKey;
 
    FGeometry CachedGeometry;
 
    TFunction<void(FGeometry)> ScrollIntoViewRequest;
 
    TSharedPtr<FActiveTimerHandle> UpdateInertialScrollHandle;
 
    double LastScrollTime;
 
    float WheelScrollMultiplier = 1.f;
 
    bool bEnableTouchScrolling = true;
 
    bool bConsumePointerInput = true;
 
    float ScrollingAnimationInterpolationSpeed = 15.f;
 
    bool bAnimateWheelScrolling : 1;
 
    bool bShowSoftwareCursor : 1;
 
    bool bScrollBarIsExternal : 1;
 
    bool bIsScrolling : 1;
 
    bool bAnimateScroll : 1;
 
    bool bScrollToEnd : 1;
 
    bool bIsScrollingActiveTimerRegistered : 1;
 
    bool bAllowsRightClickDragScrolling : 1;
    
    bool bTouchPanningCapture : 1;
 
    bool bIsFocusable : 1;
 
    bool bAllowContentToShrink = false;
};
 
class SScrollPanel : public SPanel
{
public:
 
    SLATE_BEGIN_ARGS(SScrollPanel)
    {
        _Visibility = EVisibility::SelfHitTestInvisible;
    }
 
    SLATE_ARGUMENT(EOrientation, Orientation)
    SLATE_ARGUMENT(bool, BackPadScrolling)
    SLATE_ARGUMENT(bool, FrontPadScrolling)
    SLATE_ARGUMENT(bool, AllowContentToShrink)
 
    SLATE_END_ARGS()
 
    SScrollPanel()
    : Children(this)
    {
    }
 
    void Construct(const FArguments& InArgs, TArray<SScrollBox::FSlot::FSlotArguments> InSlots);
 
public:
 
    EOrientation GetOrientation()
    {
        return Orientation;
    }
 
    void SetOrientation(EOrientation InOrientation)
    {
        Orientation = InOrientation;
    }
 
    virtual void OnArrangeChildren(const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren) const override;
 
    virtual FChildren* GetChildren() override
    {
        return &Children;
    }
 
    const FVector2D& GetArrangedSize() const
    {
        return ArrangedSize;
    }
 
    float PhysicalOffset;
    TPanelChildren<SScrollBox::FSlot> Children;
 
protected:
    // Begin SWidget overrides.
    virtual FVector2D ComputeDesiredSize(float) const override;
    // End SWidget overrides.
 
private:
 
    EOrientation Orientation;
    bool BackPadScrolling;
    bool FrontPadScrolling;
    bool bAllowContentToShrink;
    mutable FVector2D ArrangedSize;
};