STableViewBase.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 "Layout/Geometry.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "Widgets/SCompoundWidget.h"
#include "Framework/SlateDelegates.h"
#include "Framework/Layout/IScrollableWidget.h"
#include "Framework/Views/ITypedTableView.h"
#include "Framework/Layout/InertialScrollManager.h"
#include "Framework/Layout/Overscroll.h"
#include "Styling/SlateTypes.h"
#include "Widgets/SBoxPanel.h"
 
#include "STableViewBase.generated.h"
 
class FPaintArgs;
class FSlateWindowElementList;
class ITableRow;
class SHeaderRow;
class SListPanel;
class SScrollBar;
enum class EConsumeMouseWheel : uint8;
enum class ESlateVisibility : uint8;
struct FScrollBarStyle;
 
UENUM(BlueprintType)
enum class EListItemAlignment : uint8
{
    EvenlyDistributed UMETA(DisplayName = "Evenly (Padding)"),
 
    EvenlySize UMETA(DisplayName = "Evenly (Size)"),
 
    EvenlyWide UMETA(DisplayName = "Evenly (Wide)"),
 
    LeftAligned,
 
    RightAligned,
 
    CenterAligned,
 
    Fill,
};
 
UENUM(BlueprintType)
enum class EScrollIntoViewAlignment : uint8
{
    IntoView,
 
    TopOrLeft,
 
    CenterAligned,
 
    BottomOrRight
};
 
DECLARE_DELEGATE_OneParam(
    FOnTableViewScrolled,
    double );   
struct FTableViewDimensions
{
    SLATE_API FTableViewDimensions(EOrientation InOrientation);
    SLATE_API FTableViewDimensions(EOrientation InOrientation, float X, float Y);
    SLATE_API FTableViewDimensions(EOrientation InOrientation, const UE::Slate::FDeprecateVector2DParameter& Size);
 
    UE::Slate::FDeprecateVector2DResult ToVector2D() const
    {
        return Orientation == Orient_Vertical ? FVector2f(LineAxis, ScrollAxis) : FVector2f(ScrollAxis, LineAxis);
    }
 
    FTableViewDimensions operator+(const FTableViewDimensions& Other) const
    {
        return FTableViewDimensions(Orientation, ToVector2D() + Other.ToVector2D());
    }
 
    EOrientation Orientation = Orient_Vertical;
 
    float ScrollAxis = 0.f;
    
    float LineAxis = 0.f;
};
 
class STableViewBase
    : public SCompoundWidget
    , public IScrollableWidget
{
public:
 
    SLATE_API void ConstructChildren( const TAttribute<float>& InItemWidth, const TAttribute<float>& InItemHeight, const TAttribute<EListItemAlignment>& InItemAlignment, const TSharedPtr<SHeaderRow>& InHeaderRow, const TSharedPtr<SScrollBar>& InScrollBar, EOrientation InScrollOrientation, const FOnTableViewScrolled& InOnTableViewScrolled, const FScrollBarStyle* InScrollBarStyle = nullptr, const bool bInPreventThrottling = false );
 
    SLATE_API void SetItemHeight(TAttribute<float> Height);
 
    SLATE_API void SetItemWidth(TAttribute<float> Width);
 
    SLATE_API void ScrollBar_OnUserScrolled( float InScrollOffsetFraction );
 
    SLATE_API int32 GetNumGeneratedChildren() const;
 
    SLATE_API TSharedPtr<SWidget> GetGeneratedChildAt(int32 Index) const;
 
    SLATE_API TSharedPtr<SHeaderRow> GetHeaderRow() const;
 
    SLATE_API bool IsRightClickScrolling() const;
 
    SLATE_API bool IsUserScrolling() const;
 
    SLATE_API virtual void RequestListRefresh();
 
    virtual void RebuildList() = 0;
 
    SLATE_API bool IsPendingRefresh() const;
 
    const ETableViewMode::Type TableViewMode;
 
    SLATE_API void ScrollToTop();
 
    SLATE_API void ScrollToBottom();
 
    SLATE_API bool IsScrolling() const;
 
    SLATE_API float GetScrollOffset() const;
 
    SLATE_API void SetScrollOffset( const float InScrollOffset );
 
    SLATE_API void EndInertialScrolling(const bool bInShouldStopScrollNow = false);
 
    SLATE_API void AddScrollOffset(const float InScrollOffsetDelta, bool RefreshList = false);
 
    SLATE_API EVisibility GetScrollbarVisibility() const;
 
    SLATE_API void SetScrollbarVisibility(const EVisibility InVisibility);
 
    SLATE_API void SetScrollbarPadding(const FMargin& InScrollbarPadding);
 
    SLATE_API bool IsScrollbarNeeded() const;
 
    SLATE_API void SetFixedLineScrollOffset(TOptional<double> InFixedLineScrollOffset);
 
    SLATE_API void SetIsScrollAnimationEnabled(bool bInEnableScrollAnimation);
 
    SLATE_API void SetScrollingAnimationInterpolationSpeed(float InScrollingAnimationInterpolationSpeed);
 
    SLATE_API void SetEnableTouchAnimatedScrolling(bool bInEnableTouchAnimatedScrolling);
 
    SLATE_API void SetAllowOverscroll(EAllowOverscroll InAllowOverscroll);
 
    SLATE_API void SetIsRightClickScrollingEnabled(const bool bInEnableRightClickScrolling);
 
    SLATE_API void SetIsTouchScrollingEnabled(const bool bInEnableTouchScrolling);
 
    SLATE_API void SetSelectItemOnNavigation(const bool bInSelectItemOnNavigation);
 
    SLATE_API void SetWheelScrollMultiplier(float NewWheelScrollMultiplier);
 
    SLATE_API void SetIsPointerScrollingEnabled(bool bInIsPointerScrollingEnabled);
 
    SLATE_API void SetIsGamepadScrollingEnabled(bool bInIsGamepadScrollingEnabled);
 
    SLATE_API void SetBackgroundBrush(const TAttribute<const FSlateBrush*>& InBackgroundBrush);
 
public:
 
    // SWidget interface
 
    SLATE_API virtual void OnFocusLost( const FFocusEvent& InFocusEvent ) override;
    SLATE_API virtual void OnMouseCaptureLost(const FCaptureLostEvent& CaptureLostEvent) override;
    SLATE_API virtual bool SupportsKeyboardFocus() const override;
    SLATE_API virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) 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 OnMouseButtonDoubleClick( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent ) override;
    SLATE_API virtual FReply OnMouseButtonUp( 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 OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnMouseWheel( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent ) 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 bool ComputeVolatility() const 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;
 
public:
 
    // IScrollableWidget interface
 
    SLATE_API virtual FVector2D GetScrollDistance() override;
    SLATE_API virtual FVector2D GetScrollDistanceRemaining() override;
    SLATE_API virtual TSharedRef<class SWidget> GetScrollWidget() override;
 
protected:
 
    SLATE_API STableViewBase( ETableViewMode::Type InTableViewMode );
    SLATE_API virtual ~STableViewBase();
 
    SLATE_API double GetTargetScrollOffset() const;
 
    SLATE_API virtual float ScrollBy( const FGeometry& MyGeometry, float ScrollByAmount, EAllowOverscroll InAllowOverscroll );
 
    SLATE_API virtual float ScrollTo( float InScrollOffset);
 
    SLATE_API void InsertWidget( const TSharedRef<ITableRow> & WidgetToInset );
 
    SLATE_API void AppendWidget( const TSharedRef<ITableRow>& WidgetToAppend );
 
    SLATE_API const FChildren* GetConstructedTableItems() const;
 
    SLATE_API void ClearWidgets();
 
    SLATE_API void InsertPinnedWidget(const TSharedRef<SWidget>& WidgetToInset);
 
    SLATE_API void AppendPinnedWidget(const TSharedRef<SWidget>& WidgetToAppend);
 
    SLATE_API void ClearPinnedWidgets();
 
    SLATE_API float GetItemWidth() const;
 
    SLATE_API float GetItemHeight() const;
 
    SLATE_API UE::Slate::FDeprecateVector2DResult GetItemSize() const;
 
    SLATE_API virtual float GetNumLiveWidgets() const;
 
    SLATE_API virtual int32 GetNumItemsPerLine() const;
 
    SLATE_API virtual float GetFirstLineScrollOffset() const;
 
    /*
     * Right click down
     */
    virtual void OnRightMouseButtonDown(const FPointerEvent& MouseEvent) {}
 
    SLATE_API virtual void OnRightMouseButtonUp(const FPointerEvent& MouseEvent);
    
    SLATE_API float GetScrollRateInItems() const;
 
    virtual void UpdateSelectionSet() = 0;
 
    SLATE_API void RequestLayoutRefresh();
 
    struct FReGenerateResults
    {
        FReGenerateResults(double InNewScrollOffset, double InLengthGenerated, double InItemsOnScreen, bool AtEndOfList)
            : NewScrollOffset(InNewScrollOffset)
            , LengthOfGeneratedItems(InLengthGenerated)
            , ExactNumLinesOnScreen(InItemsOnScreen)
            , bGeneratedPastLastItem(AtEndOfList)
        {}
 
        double NewScrollOffset = 0.;
 
        double LengthOfGeneratedItems = 0.;
 
        double ExactNumLinesOnScreen = 0.;
 
        bool bGeneratedPastLastItem = false;
    };
    virtual FReGenerateResults ReGenerateItems( const FGeometry& MyGeometry ) = 0;
 
    virtual int32 GetNumItemsBeingObserved() const = 0;
 
    SLATE_API int32 GetNumPinnedItems() const;
 
    UE_DEPRECATED(5.5, "The Pinned items visibility is no more an attribute.")
    SLATE_API EVisibility GetPinnedItemsVisiblity() const;
 
    enum class EScrollIntoViewResult
    {
        Success,
        Deferred,
        Failure
    };
 
    virtual EScrollIntoViewResult ScrollIntoView(const FGeometry& ListViewGeometry) = 0;
 
    virtual void NotifyItemScrolledIntoView() = 0;
 
    virtual void NotifyFinishedScrolling() = 0;
 
    SLATE_API void NavigateToWidget(const uint32 UserIndex, const TSharedPtr<SWidget>& NavigationDestination, ENavigationSource NavigationSource = ENavigationSource::FocusedWidget, EUINavigation NavigationType = EUINavigation::Invalid) const;
 
    SLATE_API int32 FindChildUnderPosition(FArrangedChildren& ArrangedChildren, const FVector2D& ArrangedSpacePosition) const;
 
    TSharedPtr< SListPanel > ItemsPanel;
 
    TSharedPtr< SListPanel > PinnedItemsPanel;
 
    TSharedPtr< SScrollBar > ScrollBar;
 
    FMargin ScrollBarSlotPadding;
 
    FOnTableViewScrolled OnTableViewScrolled;
 
    inline float GetScrollComponentFromVector(FVector2f Vector) const
    {
        return float(Orientation == Orient_Vertical ? Vector.Y : Vector.X);
    }
 
    TOptional<double> FixedLineScrollOffset;
 
    bool bEnableAnimatedScrolling = false;
 
    float ScrollingAnimationInterpolationSpeed = 12.f;
 
    bool bEnableTouchAnimatedScrolling = false;
 
    bool bEnableRightClickScrolling = true;
 
    bool bEnableTouchScrolling = true;
 
    bool bSelectItemOnNavigation = true;
 
    double CurrentScrollOffset = 0.;
 
    double DesiredScrollOffset = 0.;
 
    bool bStartedTouchInteraction;
 
    float AmountScrolledWhileRightMouseDown;
 
    FVector2f PressedScreenSpacePosition;
 
    float TickScrollDelta;
 
    FReGenerateResults LastGenerateResults;
 
    bool bWasAtEndOfList;
 
    FGeometry PanelGeometryLastTick;
 
    FOnContextMenuOpening OnContextMenuOpening;
 
    FSimpleDelegate OnItemsRebuilt;
 
    TAttribute<ESelectionMode::Type> SelectionMode;
 
    TSharedPtr< SHeaderRow > HeaderRow;
 
    FInertialScrollManager InertialScrollManager;
 
    FVector2f SoftwareCursorPosition;
 
    bool bShowSoftwareCursor;
 
    float WheelScrollMultiplier;
 
    bool bIsPointerScrollingEnabled = true;
 
    bool bIsGamepadScrollingEnabled = true;
 
    EOrientation Orientation = Orient_Vertical;
 
    SLATE_API virtual void OnClippingChanged() override;
 
    bool bShouldUseShadowBoxStyle = false;
 
    const FScrollBoxStyle* ShadowBoxStyle;
 
    FInvalidatableBrushAttribute BackgroundBrush;
    
    FSlateColor GetStartShadowOpacity() const;
    
    FSlateColor GetEndShadowOpacity() const;
 
protected:
 
    SLATE_API bool CanUseInertialScroll( float ScrollAmount ) const;
 
    SLATE_API EActiveTimerReturnType UpdateInertialScroll(double InCurrentTime, float InDeltaTime);
 
    SLATE_API EActiveTimerReturnType EnsureTickToRefresh(double InCurrentTime, float InDeltaTime);
 
    bool bIsScrollingActiveTimerRegistered;
 
protected:
 
    FOverscroll Overscroll;
 
    EAllowOverscroll AllowOverscroll;
 
    EConsumeMouseWheel ConsumeMouseWheel;
 
    float GetSmoothDeltaTime(float InDeltaTime);
    void UpdateSmoothDeltaTime(float InDeltaTime);
 
private:
    bool bItemsNeedRefresh = false;
 
    bool ShouldScrollToFixedLineOffsetAtZeroVelocity() const;
 
    bool bIsInertialScroll = false;
    
    TSharedRef<SWidget> ConstructVerticalShadowBox(TSharedRef<SWidget> Content);
    
    TSharedRef<SWidget> ConstructHorizontalShadowBox(TSharedRef<SWidget> Content);
 
    const float ShadowFadeDistance = 32.0f;
 
    TArray<float> DeltaTimeQueue;
    int32 DeltaTimeCircularIndex = 0;
    TArray<float> SortedDeltaTimes;
 
    // Initialized at -1.0f to detect if the variable has been set and is usable since DeltaTimes cannot be negative.
    float SmoothDeltaTime = -1.0f;
 
    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
    };
};
 
 
namespace TableViewHelpers
{
    SLATE_API const TBitArray<>& GetEmptyBitArray();
}