SHeaderRow.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/IndirectArray.h"
#include "Misc/Attribute.h"
#include "Layout/Visibility.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Layout/Margin.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "Widgets/Layout/SBorder.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Widgets/Layout/SSplitter.h"
#include "Framework/SlateDelegates.h"
 
class FMenuBuilder;
class SScrollBar;
enum class ECheckBoxState : uint8;
 
namespace EColumnSortPriority
{
    enum Type
    {
        None,
        Primary = 0,
        Secondary = 1,
        Max,
    };
};
 
 
namespace EColumnSortMode
{
    enum Type
    {
        None = 0,
 
        Ascending = 1,
 
        Descending = 2
    };
};
 
 
namespace EColumnSizeMode
{
    enum Type
    {
        Fill = 0,
        
        Fixed = 1,
 
        Manual = 2,
 
        FillSized = 3,
    };
};
 
 
enum class EHeaderComboVisibility
{
    Always,
 
    Ghosted,
 
    OnHover,
 
    Never
};
 
 
DECLARE_DELEGATE_ThreeParams( FOnSortModeChanged, EColumnSortPriority::Type, const FName&, EColumnSortMode::Type );
 
DECLARE_DELEGATE_OneParam( FOnWidthChanged, float );
 
DECLARE_DELEGATE_RetVal_TwoParams(FVector2D, FOnGetMaxRowSizeForColumn, const FName&, EOrientation);
 
template <>
struct TWidgetTypeTraits<class SHeaderRow>
{
    static constexpr bool SupportsInvalidation() { return true; }
};
 
class SHeaderRow : public SBorder
{
public:
    class FColumn
    {
    public:
 
        SLATE_BEGIN_ARGS(FColumn)
            : _ColumnId()
            , _DefaultLabel()
            , _DefaultTooltip()
            , _ToolTip()
            , _FillWidth( 1.0f )
            , _FixedWidth()
            , _ManualWidth()
            , _OnWidthChanged()
            , _MinSize( 0.0f )
            , _HeaderContent()
            , _HAlignHeader( HAlign_Fill )
            , _VAlignHeader( VAlign_Fill )
            , _HeaderContentPadding()
            , _HeaderComboVisibility(EHeaderComboVisibility::OnHover)
            , _MenuContent()
            , _HAlignCell( HAlign_Fill )
            , _VAlignCell( VAlign_Fill )
            , _InitialSortMode( EColumnSortMode::Ascending )
            , _SortMode( EColumnSortMode::None )
            , _IsSorting( false )
            , _CanManuallySort(true)
            , _OnSort()
            , _OverflowPolicy( ETextOverflowPolicy::Clip)
            {}
            SLATE_ARGUMENT( FName, ColumnId )
            SLATE_ATTRIBUTE( FText, DefaultLabel )
            SLATE_ATTRIBUTE( FText, DefaultTooltip )
            SLATE_ATTRIBUTE( TSharedPtr< IToolTip >, ToolTip )
 
            
            SLATE_ATTRIBUTE( float, FillWidth )
            SLATE_ARGUMENT( TOptional< float >, FixedWidth )
            SLATE_ATTRIBUTE( float, ManualWidth )
            SLATE_ARGUMENT(TOptional< float >, FillSized)
            SLATE_EVENT( FOnWidthChanged, OnWidthChanged )
 
            
            SLATE_ARGUMENT(float, MinSize)
 
            SLATE_DEFAULT_SLOT( FArguments, HeaderContent )
            SLATE_ARGUMENT( EHorizontalAlignment, HAlignHeader )
            SLATE_ARGUMENT( EVerticalAlignment, VAlignHeader )
            SLATE_ARGUMENT( TOptional< FMargin >, HeaderContentPadding )
            SLATE_ARGUMENT( EHeaderComboVisibility, HeaderComboVisibility )
 
            SLATE_NAMED_SLOT( FArguments, MenuContent )
            SLATE_EVENT( FOnGetContent, OnGetMenuContent )
 
            
            SLATE_EVENT( FPointerEventHandler, OnColumnSplitterDoubleClick )
 
            SLATE_ARGUMENT( EHorizontalAlignment, HAlignCell )
            SLATE_ARGUMENT( EVerticalAlignment, VAlignCell )
 
            SLATE_ATTRIBUTE( EColumnSortMode::Type, InitialSortMode )
            SLATE_ATTRIBUTE( EColumnSortMode::Type, SortMode )
            SLATE_ATTRIBUTE( EColumnSortPriority::Type, SortPriority )
            SLATE_ATTRIBUTE( bool, IsSorting )
            SLATE_ATTRIBUTE( bool, CanManuallySort)
            SLATE_EVENT( FOnSortModeChanged, OnSort )
 
            SLATE_ATTRIBUTE(bool, ShouldGenerateWidget)
            SLATE_ATTRIBUTE(bool, ShouldGenerateEmptyWidgetForSpacing)
            SLATE_ARGUMENT(ETextOverflowPolicy, OverflowPolicy)
        SLATE_END_ARGS()
 
        FColumn( const FArguments& InArgs )
            : ColumnId( InArgs._ColumnId )
            , DefaultText( InArgs._DefaultLabel )
            , DefaultTooltip( InArgs._DefaultTooltip )
            , ToolTip(InArgs._ToolTip)
            , Width( 1.0f )
            , DefaultWidth( 1.0f )
            , OnWidthChanged( InArgs._OnWidthChanged)
            , MinSize( InArgs._MinSize )
            , SizeRule( EColumnSizeMode::Fill )
            , HeaderContent( InArgs._HeaderContent )
            , HeaderMenuContent( InArgs._MenuContent )
            , OnGetMenuContent( InArgs._OnGetMenuContent )
            , OnColumnSplitterDoubleClick( InArgs._OnColumnSplitterDoubleClick )
            , HeaderHAlignment( InArgs._HAlignHeader )
            , HeaderVAlignment( InArgs._VAlignHeader )
            , HeaderContentPadding( InArgs._HeaderContentPadding )
            , HeaderComboVisibility (InArgs._HeaderComboVisibility )
            , CellHAlignment( InArgs._HAlignCell )
            , CellVAlignment( InArgs._VAlignCell )
            , OverflowPolicy(InArgs._OverflowPolicy)
            , InitialSortMode( InArgs._InitialSortMode )
            , SortMode( InArgs._SortMode )
            , SortPriority( InArgs._SortPriority )
            , IsSorting( InArgs._IsSorting)
            , CanManuallySort(InArgs._CanManuallySort)
            , OnSortModeChanged( InArgs._OnSort )
            , ShouldGenerateWidget(InArgs._ShouldGenerateWidget)
            , ShouldGenerateEmptyWidgetForSpacing(InArgs._ShouldGenerateEmptyWidgetForSpacing)
            , bIsVisible(true)
            {
            if ( InArgs._FixedWidth.IsSet() )
            {
                Width = InArgs._FixedWidth.GetValue();
                SizeRule = EColumnSizeMode::Fixed;
            }
            else if ( InArgs._ManualWidth.IsSet() )
            {
                Width = InArgs._ManualWidth;
                SizeRule = EColumnSizeMode::Manual;
            }
            else if ( InArgs._FillSized.IsSet() )
            {
                Width = InArgs._FillSized.GetValue();
                SizeRule = EColumnSizeMode::FillSized;
            }
            else
            {
                Width = InArgs._FillWidth;
                SizeRule = EColumnSizeMode::Fill;
            }
 
            DefaultWidth = Width.Get();
        }
 
    public:
 
        void SetWidth( float NewWidth )
        {
            if ( OnWidthChanged.IsBound() )
            {
                OnWidthChanged.Execute( NewWidth );
            }
            else
            {
                Width = NewWidth;
            }
        }
 
        float GetWidth() const
        {
            return Width.Get();
        }
 
        FName ColumnId;
 
        TAttribute< FText > DefaultText;
 
        TAttribute< FText > DefaultTooltip;
 
        TAttribute< TSharedPtr< IToolTip > > ToolTip;
 
        TAttribute< float > Width;
 
        float DefaultWidth;
 
        FOnWidthChanged OnWidthChanged;
 
        float MinSize;
 
        EColumnSizeMode::Type SizeRule;
 
        TAlwaysValidWidget HeaderContent;   
        TAlwaysValidWidget HeaderMenuContent;
 
        FOnGetContent OnGetMenuContent;
        FPointerEventHandler OnColumnSplitterDoubleClick;
 
        EHorizontalAlignment HeaderHAlignment;
        EVerticalAlignment HeaderVAlignment;
        TOptional< FMargin > HeaderContentPadding;
        EHeaderComboVisibility HeaderComboVisibility;
 
        EHorizontalAlignment CellHAlignment;
        EVerticalAlignment CellVAlignment;
 
        ETextOverflowPolicy OverflowPolicy;
 
        TAttribute< EColumnSortMode::Type > InitialSortMode;
        TAttribute< EColumnSortMode::Type > SortMode;
        TAttribute< EColumnSortPriority::Type > SortPriority;
        TAttribute< bool > IsSorting;
        TAttribute< bool > CanManuallySort;
        FOnSortModeChanged OnSortModeChanged;
 
        TAttribute<bool> ShouldGenerateWidget;
        TAttribute<bool> ShouldGenerateEmptyWidgetForSpacing;
        bool bIsVisible;
    };
 
    static FColumn::FArguments Column( const FName& InColumnId )
    {
        FColumn::FArguments NewArgs;
        NewArgs.ColumnId( InColumnId ); 
        return NewArgs;
    }
 
    DECLARE_EVENT_OneParam( SHeaderRow, FColumnsChanged, const TSharedRef< SHeaderRow >& );
    FColumnsChanged* OnColumnsChanged() { return &ColumnsChanged; }
 
    SLATE_BEGIN_ARGS(SHeaderRow)
        : _Style( &FAppStyle::Get().GetWidgetStyle<FHeaderRowStyle>("TableView.Header") )
        , _ResizeMode(ESplitterResizeMode::Fill)
        , _CanSelectGeneratedColumn(false)
        {}
 
        SLATE_STYLE_ARGUMENT( FHeaderRowStyle, Style )
        SLATE_SUPPORTS_SLOT_WITH_ARGS( FColumn )    
        SLATE_EVENT( FColumnsChanged::FDelegate, OnColumnsChanged )
        SLATE_EVENT( FOnGetMaxRowSizeForColumn, OnGetMaxRowSizeForColumn )
        SLATE_ARGUMENT( ESplitterResizeMode::Type, ResizeMode )
        SLATE_ARGUMENT( TOptional<float>, SplitterHandleSize )
        SLATE_ARGUMENT( bool, CanSelectGeneratedColumn )
        SLATE_ARGUMENT( TArray<FName>, HiddenColumnsList )
        SLATE_EVENT( FSimpleDelegate, OnHiddenColumnsListChanged )
    SLATE_END_ARGS()
 
    SLATE_API void Construct( const FArguments& InArgs );
 
    SLATE_API void ResetColumnWidths();
 
    SLATE_API const TIndirectArray<FColumn>& GetColumns() const;
 
    SLATE_API void AddColumn( const FColumn::FArguments& NewColumnArgs );
    SLATE_API void AddColumn( FColumn& NewColumn );
 
    SLATE_API void InsertColumn( const FColumn::FArguments& NewColumnArgs, int32 InsertIdx );
    SLATE_API void InsertColumn( FColumn& NewColumn, int32 InsertIdx );
 
    SLATE_API void RemoveColumn( const FName& InColumnId );
 
    SLATE_API void RefreshColumns();
 
    SLATE_API void ClearColumns();
 
    SLATE_API void SetAssociatedVerticalScrollBar( const TSharedRef< SScrollBar >& ScrollBar, const float ScrollBarSize );
 
    SLATE_API void SetColumnWidth( const FName& InColumnId, float InWidth );
 
    SLATE_API FVector2D GetRowSizeForSlotIndex(int32 SlotIndex) const;
 
    void SetOnGetMaxRowSizeForColumn(const FOnGetMaxRowSizeForColumn& Delegate) { OnGetMaxRowSizeForColumn = Delegate; }
 
    SLATE_API TArray<FName> GetHiddenColumnIds() const;
 
    SLATE_API bool ShouldGeneratedColumn( const FName& InColumnId ) const;
 
    SLATE_API bool ShouldGenerateEmptyColumnForSpacing( const FName& InColumnId ) const;
 
    SLATE_API bool IsColumnGenerated( const FName& InColumnId ) const;
 
    SLATE_API bool IsColumnVisible( const FName& InColumnId ) const;
 
    //~ Begin SWidget interface
    SLATE_API virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    //~ End SWidget interface
 
    SLATE_API void SetShowGeneratedColumn(const FName& InColumnIdm, bool InShow = true);
 
 
private:
 
    SLATE_API void RegenerateWidgets();
 
    void ToggleAllColumns();
    bool CanToggleAllColumns() const;
    ECheckBoxState GetSelectAllColumnsCheckState() const;
    FText GetToggleAllColumnsText() const;
 
    void OnGenerateSelectColumnsSubMenu(FMenuBuilder& InSubMenuBuilder);
    SLATE_API void ToggleGeneratedColumn(FName ColumnId);
    SLATE_API ECheckBoxState GetGeneratedColumnCheckedState(FName ColumnId) const;
 
    TIndirectArray<FColumn> Columns;
    TArray<TSharedPtr<class STableColumnHeader>> HeaderWidgets;
 
    FVector2f ScrollBarThickness;
    TAttribute< EVisibility > ScrollBarVisibility;
    const FHeaderRowStyle* Style;
    FColumnsChanged ColumnsChanged;
    ESplitterResizeMode::Type ResizeMode;
    float SplitterHandleSize;
    FOnGetMaxRowSizeForColumn OnGetMaxRowSizeForColumn;
 
    FSimpleDelegate OnHiddenColumnsListChanged;
    bool bCanSelectGeneratedColumn;
};