SGridPanel.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/Visibility.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "SlotBase.h"
#include "Widgets/SWidget.h"
#include "Layout/Children.h"
#include "Widgets/SPanel.h"
 
class FArrangedChildren;
class FPaintArgs;
class FSlateWindowElementList;
 
class SGridPanel : public SPanel
{
    SLATE_DECLARE_WIDGET_API(SGridPanel, SPanel, SLATE_API)
 
public:
    // Used by the mandatory named parameter in FSlot
    class Layer
    {
    public:
        explicit Layer(int32 InLayer)
            : TheLayer(InLayer)
        {
 
        }
 
        int32 TheLayer;
    };
 
    class FSlot : public TBasicLayoutWidgetSlot<FSlot>
    {
        friend SGridPanel;
 
        public:
            FSlot( int32 Column, int32 Row, int32 InLayer )
                : TBasicLayoutWidgetSlot<FSlot>(HAlign_Fill, VAlign_Fill)
                , ColumnParam( Column )
                , ColumnSpanParam( 1 )
                , RowParam( Row )
                , RowSpanParam( 1 )
                , LayerParam( InLayer )
                , NudgeParam( FVector2D::ZeroVector )
            {
            }
 
            SLATE_SLOT_BEGIN_ARGS(FSlot, TBasicLayoutWidgetSlot<FSlot>)
                SLATE_ARGUMENT(TOptional<int32>, Column)
                SLATE_ARGUMENT(TOptional<int32>, ColumnSpan)
                SLATE_ARGUMENT(TOptional<int32>, Row)
                SLATE_ARGUMENT(TOptional<int32>, RowSpan)
                SLATE_ARGUMENT(TOptional<int32>, Layer)
                SLATE_ARGUMENT(TOptional<FVector2D>, Nudge)
            SLATE_SLOT_END_ARGS()
 
            SLATE_API void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs);
 
        public:
            int32 GetColumn() const
            {
                return ColumnParam;
            }
 
            void SetColumn(int32 Column)
            {
                Column = FMath::Max(0, Column);
                if (Column != ColumnParam)
                {
                    ColumnParam = Column;
                    NotifySlotChanged();
                }
            }
 
            int32 GetColumnSpan() const
            {
                return ColumnSpanParam;
            }
 
            void SetColumnSpan(int32 ColumnSpan)
            {
                // clamp span to a sensible size, otherwise computing slot sizes can slow down dramatically
                ColumnSpan = FMath::Clamp(ColumnSpan, 1, 10000);
                if (ColumnSpan != ColumnSpanParam)
                {
                    ColumnSpanParam = ColumnSpan;
                    NotifySlotChanged();
                }
            }
 
            int32 GetRow() const
            {
                return RowParam;
            }
 
            void SetRow(int32 Row)
            {
                Row = FMath::Max(0, Row);
                if (Row != RowParam)
                {
                    RowParam = Row;
                    NotifySlotChanged();
                }
            }
 
            int32 GetRowSpan() const
            {
                return RowSpanParam;
            }
 
            void SetRowSpan(int32 RowSpan)
            {
                // clamp span to a sensible size, otherwise computing slots sizes can slow down dramatically
                RowSpan = FMath::Clamp(RowSpan, 1, 10000);
                if (RowSpan != RowSpanParam)
                {
                    RowSpanParam = RowSpan;
                    NotifySlotChanged();
                }
            }
 
            int32 GetLayer() const
            {
                return LayerParam;
            }
 
            void SetLayer(int32 Layer)
            {
                if (Layer != LayerParam)
                {
                    LayerParam = Layer;
                    const bool bSlotLayerChanged = true;
                    NotifySlotChanged(bSlotLayerChanged);
                }
            }
 
            FVector2D GetNudge() const
            {
                return NudgeParam;
            }
 
            void SetNudge(const FVector2D& Nudge)
            {
                NudgeParam = Nudge;
                Invalidate(EInvalidateWidgetReason::Paint);
            }
 
        private:
            TWeakPtr<SGridPanel> Panel;
 
            int32 ColumnParam;
            int32 ColumnSpanParam;
            int32 RowParam;
            int32 RowSpanParam;
            int32 LayerParam;
            FVector2D NudgeParam;
 
            inline void NotifySlotChanged(bool bSlotLayerChanged = false)
            {
                if ( Panel.IsValid() )
                {
                    Panel.Pin()->NotifySlotChanged(this, bSlotLayerChanged);
                }
            }
    };
 
    static SLATE_API FSlot::FSlotArguments Slot( int32 Column, int32 Row, Layer InLayer = Layer(0) );
 
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    SLATE_API FScopedWidgetSlotArguments AddSlot( int32 Column, int32 Row, Layer InLayer = Layer(0) );
 
    SLATE_API bool RemoveSlot(const TSharedRef<SWidget>& SlotWidget);
 
    SLATE_BEGIN_ARGS( SGridPanel )
        {
            _Visibility = EVisibility::SelfHitTestInvisible;
        }
 
        SLATE_SLOT_ARGUMENT( FSlot, Slots )
 
        
        FArguments& FillColumn( int32 ColumnId, const TAttribute<float>& Coefficient )
        {
            while (ColFillCoefficients.Num() <= ColumnId)
            {
                ColFillCoefficients.Emplace( 0 );
            }
            ColFillCoefficients[ColumnId] = Coefficient;
            return Me();
        }
 
        FArguments& FillRow( int32 RowId, const TAttribute<float>& Coefficient )
        {
            while (RowFillCoefficients.Num() <= RowId)
            {
                RowFillCoefficients.Emplace( 0 );
            }
            RowFillCoefficients[RowId] = Coefficient;
            return Me();
        }
 
        TArray<TAttribute<float>> ColFillCoefficients;
        
        TArray<TAttribute<float>> RowFillCoefficients;
        
    SLATE_END_ARGS()
 
    SLATE_API SGridPanel();
    SLATE_API virtual ~SGridPanel();
 
    SLATE_API void ClearChildren();
    
    SLATE_API void Construct( const FArguments& InArgs );
 
    SLATE_API FVector2D GetDesiredRegionSize( const FIntPoint& StartCell, int32 Width, int32 Height ) const;
 
    SLATE_API void SetColumnFill( int32 ColumnId, const TAttribute<float>& Coefficient );
 
    SLATE_API void SetRowFill( int32 RowId, const TAttribute<float>& Coefficient );
 
    SLATE_API void ClearFill();
 
public:
 
    // SWidget interface
 
    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 void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override;
    SLATE_API virtual void CacheDesiredSize(float) override;
    SLATE_API virtual FVector2D ComputeDesiredSize(float) const override;
    SLATE_API virtual FChildren* GetChildren() override;
 
private:
 
    static SLATE_API void ComputePartialSums( TArray<float>& TurnMeIntoPartialSums );
    
    static SLATE_API void DistributeSizeContributions( float SizeContribution, TArray<float>& DistributeOverMe, int32 StartIndex, int32 UpperBound );
 
    SLATE_API int32 FindInsertSlotLocation( const FSlot* InSlot );
 
    SLATE_API void ComputeDesiredCellSizes( TArray<float>& OutColumns, TArray<float>& OutRows ) const;
 
    SLATE_API int32 LayoutDebugPaint(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId ) const;
    
    SLATE_API void NotifySlotChanged(const FSlot* InSlot, bool bSlotLayerChanged = false);
 
private:
 
    TPanelChildren<FSlot> Slots;
 
    TArray<float> Columns;
    
    TArray<float> Rows;
 
    FVector2D TotalDesiredSizes;
 
protected:
    mutable TArray<TAttribute<float>> ColFillCoefficients;
 
    mutable TArray<TAttribute<float>> RowFillCoefficients;
};