SWrapBox.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 SWrapBox : public SPanel
{
    SLATE_DECLARE_WIDGET_API(SWrapBox, SPanel, SLATE_API)
public:
 
    class FSlot : public TBasicLayoutWidgetSlot<FSlot>
    {
    public:
        FSlot()
            : TBasicLayoutWidgetSlot<FSlot>(HAlign_Fill, VAlign_Fill)
            , SlotFillLineWhenSizeLessThan()
            , bSlotFillEmptySpace(false)
            , bSlotForceNewLine(false)
        {
        }
 
        SLATE_SLOT_BEGIN_ARGS(FSlot, TBasicLayoutWidgetSlot<FSlot>)
            SLATE_ARGUMENT(TOptional<float>, FillLineWhenSizeLessThan)
            SLATE_ARGUMENT(TOptional<bool>, FillEmptySpace)
            SLATE_ARGUMENT(TOptional<bool>, ForceNewLine)
        SLATE_SLOT_END_ARGS()
 
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            TBasicLayoutWidgetSlot<FSlot>::Construct(SlotOwner, MoveTemp(InArgs));
            if (InArgs._FillLineWhenSizeLessThan.IsSet())
            {
                SlotFillLineWhenSizeLessThan = InArgs._FillLineWhenSizeLessThan;
            }
            bSlotFillEmptySpace = InArgs._FillEmptySpace.Get(bSlotFillEmptySpace);
            bSlotForceNewLine = InArgs._ForceNewLine.Get(bSlotForceNewLine);
        }
 
        void SetFillLineWhenSizeLessThan(TOptional<float> InFillLineWhenSizeLessThan)
        {
            if (SlotFillLineWhenSizeLessThan != InFillLineWhenSizeLessThan)
            {
                SlotFillLineWhenSizeLessThan = InFillLineWhenSizeLessThan;
                FSlotBase::Invalidate(EInvalidateWidgetReason::Layout);
            }
        }
 
        TOptional<float> GetFillLineWhenSizeLessThan() const
        {
            return SlotFillLineWhenSizeLessThan;
        }
 
        void SetFillEmptySpace(bool bInFillEmptySpace)
        {
            if (bSlotFillEmptySpace != bInFillEmptySpace)
            {
                bSlotFillEmptySpace = bInFillEmptySpace;
                FSlotBase::Invalidate(EInvalidateWidgetReason::Layout);
            }
        }
 
        bool GetFillEmptySpace() const
        {
            return bSlotFillEmptySpace;
        }
 
        void SetForceNewLine(bool bInForceNewLine)
        {
            if (bSlotForceNewLine != bInForceNewLine)
            {
                bSlotForceNewLine = bInForceNewLine;
                FSlotBase::Invalidate(EInvalidateWidgetReason::Layout);
            }
        }
 
        bool GetForceNewLine() const
        {
            return bSlotForceNewLine;
        }
 
    private:
        TOptional<float> SlotFillLineWhenSizeLessThan;
        bool bSlotFillEmptySpace;
        bool bSlotForceNewLine;
    };
 
 
    SLATE_BEGIN_ARGS(SWrapBox)
        : _PreferredSize(100.f)
        , _HAlign(HAlign_Left)
        , _InnerSlotPadding(FVector2D::ZeroVector)
        , _UseAllottedSize(false)
        , _Orientation(EOrientation::Orient_Horizontal)
        {
            _Visibility = EVisibility::SelfHitTestInvisible;
        }
 
        SLATE_SLOT_ARGUMENT( FSlot, Slots )
 
        
        SLATE_ATTRIBUTE( float, PreferredSize )
 
        
        SLATE_ATTRIBUTE(EHorizontalAlignment, HAlign)
 
        
        SLATE_ARGUMENT( FVector2D, InnerSlotPadding )
 
        
        SLATE_ARGUMENT( bool, UseAllottedSize )
 
        
        SLATE_ARGUMENT(EOrientation, Orientation);
    SLATE_END_ARGS()
 
    SLATE_API SWrapBox();
    SLATE_API virtual ~SWrapBox();
 
    static FSlot::FSlotArguments Slot()
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>());
    }
 
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    SLATE_API FScopedWidgetSlotArguments AddSlot();
 
    SLATE_API int32 RemoveSlot( const TSharedRef<SWidget>& SlotWidget );
 
    SLATE_API void Construct( const FArguments& InArgs );
 
    SLATE_API virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) override;
 
    SLATE_API virtual void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override;
 
    SLATE_API void ClearChildren();
 
    SLATE_API virtual FVector2D ComputeDesiredSize(float) const override;
 
    SLATE_API virtual FChildren* GetChildren() override;
 
    SLATE_API void SetInnerSlotPadding(FVector2D InInnerSlotPadding);
 
    SLATE_API void SetWrapSize(TAttribute<float> InWrapSize );
 
    SLATE_API void SetUseAllottedSize(bool bInUseAllottedSize);
 
    SLATE_API void SetOrientation(EOrientation InOrientation);
 
    SLATE_API void SetHorizontalAlignment(TAttribute<EHorizontalAlignment> InHAlignment);
 
private:
    TSlateAttribute<float> PreferredSize;
 
    TSlateAttribute< EHorizontalAlignment > HAlign;
 
    TPanelChildren<FSlot> Slots;
 
    FVector2D InnerSlotPadding;
 
    bool bUseAllottedSize;
 
    EOrientation Orientation;
 
    class FChildArranger;
    friend class SWrapBox::FChildArranger;
};