SUniformWrapPanel.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 "SlotBase.h"
#include "Layout/Margin.h"
#include "Layout/Children.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SPanel.h"
#include "Types/SlateEnums.h"
 
class FArrangedChildren;
 
class SUniformWrapPanel : public SPanel
{
    SLATE_DECLARE_WIDGET_API(SUniformWrapPanel, SPanel, SLATE_API)
 
public:
    struct FSlot : public TSlotBase<FSlot>, public TAlignmentWidgetSlotMixin<FSlot>
    {
        FSlot()
            : TSlotBase<FSlot>()
            , TAlignmentWidgetSlotMixin<FSlot>(HAlign_Fill, VAlign_Fill)
        { }
 
        SLATE_SLOT_BEGIN_ARGS_OneMixin(FSlot, TSlotBase<FSlot>, TAlignmentWidgetSlotMixin<FSlot>)
        SLATE_SLOT_END_ARGS()
 
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            TSlotBase<FSlot>::Construct(SlotOwner, MoveTemp(InArgs));
            TAlignmentWidgetSlotMixin<FSlot>::ConstructMixin(SlotOwner, MoveTemp(InArgs));
        }
    };
 
    SLATE_API SUniformWrapPanel();
    SLATE_API virtual ~SUniformWrapPanel();
 
    static FSlot::FSlotArguments Slot()
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>());
    }
 
    SLATE_BEGIN_ARGS( SUniformWrapPanel )
        : _SlotPadding( FMargin(0.0f) )
        , _NumColumnsOverride( 0 )
        , _MinDesiredSlotWidth( 0.0f )
        , _MinDesiredSlotHeight( 0.0f )
        , _MaxDesiredSlotWidth( FLT_MAX )
        , _MaxDesiredSlotHeight( FLT_MAX )
        , _EvenRowDistribution(false)
        , _HAlign(EHorizontalAlignment::HAlign_Left)
        {
            _Visibility = EVisibility::SelfHitTestInvisible;
        }
 
        SLATE_SLOT_ARGUMENT(FSlot, Slots)
        
        
        SLATE_ATTRIBUTE(FMargin, SlotPadding)
 
        
        SLATE_ATTRIBUTE(int32, NumColumnsOverride)
    
        
        SLATE_ATTRIBUTE(float, MinDesiredSlotWidth)
 
        
        SLATE_ATTRIBUTE(float, MinDesiredSlotHeight)
 
        
        SLATE_ATTRIBUTE(float, MaxDesiredSlotWidth)
 
        
        SLATE_ATTRIBUTE(float, MaxDesiredSlotHeight)
 
        
        SLATE_ATTRIBUTE(bool, EvenRowDistribution)
 
        
        SLATE_ATTRIBUTE(EHorizontalAlignment, HAlign )
 
    SLATE_END_ARGS()
 
    SLATE_API void Construct( const FArguments& InArgs );
 
    //~ Begin SPanel Interface  
    SLATE_API virtual void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override;
    SLATE_API virtual FChildren* GetChildren() override;
    //~ End SPanel Interface
 
    SLATE_API void SetSlotPadding(TAttribute<FMargin> InSlotPadding);
 
    SLATE_API void SetMinDesiredSlotWidth(TAttribute<float> InMinDesiredSlotWidth);
 
    SLATE_API void SetMinDesiredSlotHeight(TAttribute<float> InMinDesiredSlotHeight);
 
    SLATE_API void SetNumColumnsOverride(TAttribute<int32> InNumColumnsOverride);
    
    SLATE_API void SetMaxDesiredSlotWidth(TAttribute<float> InMaxDesiredSlotWidth);
 
    SLATE_API void SetMaxDesiredSlotHeight(TAttribute<float> InMaxDesiredSlotHeight);
 
    SLATE_API void SetHorizontalAlignment(TAttribute<EHorizontalAlignment> InHAlignment);
    EHorizontalAlignment GetHorizontalAlignment() { return HAlign.Get(); }
 
    SLATE_API void SetEvenRowDistribution(TAttribute<bool> InEvenRowDistribution);
    bool GetEvenRowDistribution() { return EvenRowDistribution.Get(); }
 
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    SLATE_API FScopedWidgetSlotArguments AddSlot();
    
    SLATE_API bool RemoveSlot( const TSharedRef<SWidget>& SlotWidget );
 
    SLATE_API void ClearChildren();
 
    int32 NumSlots() const { return Children.Num(); }
 
protected:
    // Begin SWidget overrides.
    SLATE_API virtual FVector2D ComputeDesiredSize(float) const override;
    // End SWidget overrides.
 
    SLATE_API FVector2D ComputeUniformCellSize() const;
 
private:
    TPanelChildren<FSlot> Children;
    TSlateAttribute<FMargin> SlotPadding;
    
    mutable int32 NumColumns;
    mutable int32 NumRows;
    mutable int32 NumVisibleChildren;
 
    TSlateAttribute<int32> NumColumnsOverride;
    
    TSlateAttribute<float> MinDesiredSlotWidth;
    TSlateAttribute<float> MinDesiredSlotHeight;
 
    TSlateAttribute<float> MaxDesiredSlotWidth;
    TSlateAttribute<float> MaxDesiredSlotHeight;
 
    TSlateAttribute<EHorizontalAlignment> HAlign;
    TSlateAttribute<bool> EvenRowDistribution;
};