SResponsiveGridPanel.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 "Widgets/DeclarativeSyntaxSupport.h"
#include "SlotBase.h"
#include "Widgets/SWidget.h"
#include "Layout/Children.h"
#include "Widgets/SPanel.h"
 
class FArrangedChildren;
class FPaintArgs;
class FSlateWindowElementList;
 
namespace SResponsiveGridSize
{
    enum Type
    {
        Mobile = 0,
        Tablet = 768,
        MediumDevice = 992,
        LargeDevice = 1200,
    };
}
 
class SResponsiveGridPanel : public SPanel
{
    SLATE_DECLARE_WIDGET_API(SResponsiveGridPanel, SPanel, SLATE_API)
public:
 
    class FSlot : public TBasicLayoutWidgetSlot< FSlot >
    {
    private:
        friend SResponsiveGridPanel;
        struct FColumnLayout
        {
            float LayoutSize;
            int32 Span;
            int32 Offset;
        };
 
    public:
        FSlot(int32 Row)
            : TBasicLayoutWidgetSlot<FSlot>(HAlign_Fill, VAlign_Fill)
            , RowParam(FMath::Max(0, Row))
            , ColumnLayouts()
        { }
 
 
        SLATE_SLOT_BEGIN_ARGS(FSlot, TBasicLayoutWidgetSlot<FSlot>)
            FSlot::FSlotArguments& ColumnSpan(float LayoutSize, int32 ColumnSpan, int32 ColumnOffset = 0)
            {
                FColumnLayout ColumnLayout;
                ColumnLayout.LayoutSize = LayoutSize;
                ColumnLayout.Span = FMath::Max(0, ColumnSpan);
                ColumnLayout.Offset = ColumnOffset;
 
                bool Inserted = false;
                for (int32 Index = 0; Index < ColumnLayouts.Num(); Index++)
                {
                    if (ColumnLayout.LayoutSize < ColumnLayouts[Index].LayoutSize)
                    {
                        ColumnLayouts.Insert(ColumnLayout, Index);
                        Inserted = true;
                        break;
                    }
                }
 
                if (!Inserted)
                {
                    ColumnLayouts.Add(ColumnLayout);
                }
 
                return *this;
            }
        
            TArray<FColumnLayout> ColumnLayouts;
        SLATE_SLOT_END_ARGS()
 
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            TBasicLayoutWidgetSlot<FSlot>::Construct(SlotOwner, MoveTemp(InArgs));
            ColumnLayouts = MoveTemp(InArgs.ColumnLayouts);
        }
 
    private:
        TWeakPtr<SResponsiveGridPanel> Panel;
 
        int32 RowParam;
 
        TArray<FColumnLayout> ColumnLayouts;
    };
 
    static FSlot::FSlotArguments Slot(int32 Row)
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>(Row));
    }
 
    SLATE_BEGIN_ARGS(SResponsiveGridPanel)
        : _ColumnGutter(0)
        , _RowGutter(0)
        {
            _Visibility = EVisibility::SelfHitTestInvisible;
        }
 
        SLATE_ARGUMENT(float, ColumnGutter)
        SLATE_ARGUMENT(float, RowGutter)
 
        SLATE_SLOT_ARGUMENT(FSlot, Slots)
 
        
        FArguments& FillRow(int32 RowId, float Coefficient)
        {
            if (RowFillCoefficients.Num() <= RowId)
            {
                RowFillCoefficients.AddZeroed(RowId - RowFillCoefficients.Num() + 1);
            }
            RowFillCoefficients[RowId] = Coefficient;
            return Me();
        }
 
        TArray<float> RowFillCoefficients;
 
    SLATE_END_ARGS()
 
    SLATE_API SResponsiveGridPanel();
    SLATE_API virtual ~SResponsiveGridPanel();
 
    SLATE_API void ClearChildren();
    
    SLATE_API void Construct( const FArguments& InArgs, int32 TotalColumns );
 
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    SLATE_API FScopedWidgetSlotArguments AddSlot(int32 Row);
 
    SLATE_API bool RemoveSlot(const TSharedRef<SWidget>& SlotWidget);
 
    SLATE_API void SetRowFill(int32 RowId, float Coefficient);
 
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 FChildren* GetChildren() override;
 
protected:
    //~ Begin SWidget overrides.
    SLATE_API virtual FVector2D ComputeDesiredSize(float) const override;
    //~ End SWidget overrides.
 
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(SResponsiveGridPanel::FSlot* InSlot) const;
 
    SLATE_API void ComputeDesiredCellSizes(float AvailableWidth, TArray<float>& OutColumns, TArray<float>& OutRows, TArray<float>& OutRowToSlot) const;
 
    SLATE_API int32 LayoutDebugPaint(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId ) const;
 
private:
 
    TPanelChildren<FSlot> Slots;
 
    int32 TotalColumns;
    float ColumnGutter;
    float RowGutter;
 
    TArray<float> RowFillCoefficients;
 
    FVector2D TotalDesiredSizes;
 
    mutable float PreviousWidth;
};