SPrioritizedWrapBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Framework/MultiBox/MultiBoxDefs.h"
#include "Framework/SlateDelegates.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/Layout/SWrapBox.h"
#include "Widgets/SBoxPanel.h"
 
class FArrangedChildren;
class FPaintArgs;
class FSlateWindowElementList;
class SComboButton;
 
DECLARE_DELEGATE_RetVal_OneParam(FMenuEntryResizeParams, FOnGetWidgetResizeParams, const TSharedRef<SWidget>&);
 
namespace UE::Slate::PrioritizedWrapBox
{
    class FChildArranger;
}; // namespace UE::Slate
 
class SPrioritizedWrapBox : public SPanel
{
    SLATE_DECLARE_WIDGET(SPrioritizedWrapBox, SPanel)
 
public:
    class FSlot : public TBasicLayoutWidgetSlot<FSlot>, public TResizingWidgetSlotMixin<FSlot>
    {
    public:
        SLATE_SLOT_BEGIN_ARGS_OneMixin(FSlot, TBasicLayoutWidgetSlot<FSlot>, TResizingWidgetSlotMixin<FSlot>)
            SLATE_ATTRIBUTE(bool, AllowWrapping) // If set to false, this widget won't be considered for wrapping and will always be in the first line
            SLATE_ATTRIBUTE(int32, WrapPriority)
            SLATE_ATTRIBUTE(UE::Slate::PrioritizedWrapBox::EWrapMode, WrapMode)
            SLATE_ARGUMENT_DEFAULT(UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior, VerticalOverflowBehavior) = UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior::Default;
            SLATE_ARGUMENT(TOptional<float>, VerticalExpansionThreshold) // Vertical expansion will occur when the widget's desired size is at or beyond this value
            SLATE_ARGUMENT_DEFAULT(bool, ForceNewLine) = false; // If true, this will forcibly place this slot on a new line, regardless of the wrapping behavior. This affects all slots after this one with the same or higher wrapping priorities.
            SLATE_ARGUMENT_DEFAULT(bool, ExcludeIfFirstOrLast) = false;
        SLATE_SLOT_END_ARGS()
 
        FSlot();
 
    public:
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs);
 
        static void RegisterAttributes(FSlateWidgetSlotAttributeInitializer& AttributeInitializer);
 
        bool GetAllowWrapping() const { return bAllowWrapping.Get(); }
 
        int32 GetWrapPriority() const { return WrapPriority.Get(); }
 
        void SetWrapPriority(int32 InPriority) { WrapPriority.Set(*this, InPriority); }
 
        UE::Slate::PrioritizedWrapBox::EWrapMode GetWrapMode() const { return WrapMode.Get(); }
 
        UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior GetVerticalOverflowBehavior() const { return VerticalOverflowBehavior; }
 
        const TOptional<float>& GetVerticalExpansionThreshold() const { return VerticalExpansionThreshold; }
 
        const bool GetForceNewLine() const { return bForceNewLine; }
 
        bool GetExcludeIfFirstOrLast() const { return bExcludeIfFirstOrLast; }
 
    private:
        template <typename InObjectType>
        using TSlateSlotAttribute = ::SlateAttributePrivate::TSlateContainedAttribute<InObjectType, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeComparePredicate<>>;
 
        TSlateSlotAttribute<bool> bAllowWrapping;
 
        TSlateSlotAttribute<int32> WrapPriority;
 
        TSlateSlotAttribute<UE::Slate::PrioritizedWrapBox::EWrapMode> WrapMode;
 
        UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior VerticalOverflowBehavior = UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior::Default;
        TOptional<float> VerticalExpansionThreshold;
        bool bForceNewLine = false;;
 
        bool bExcludeIfFirstOrLast = false;
    };
 
    SLATE_BEGIN_ARGS(SPrioritizedWrapBox)
        : _PreferredSize(100.0f)
        , _MinLineHeight(TOptional<float>())
        , _LinePadding(0.0f)
        , _GroupedWrapping(false)
    { }
        SLATE_SLOT_ARGUMENT(FSlot, Slots)
 
        
        SLATE_ATTRIBUTE(float, PreferredSize)
 
        
        SLATE_ATTRIBUTE(TOptional<float>, MinLineHeight)
 
        
        SLATE_ARGUMENT(float, LinePadding)
 
        
        SLATE_ARGUMENT(bool, GroupedWrapping)
    SLATE_END_ARGS()
 
    SPrioritizedWrapBox();
    virtual ~SPrioritizedWrapBox() override;
 
    static FSlot::FSlotArguments Slot()
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>());
    }
 
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    FScopedWidgetSlotArguments AddSlot();
    int32 RemoveSlot(const TSharedRef<SWidget>& InSlot);
 
    void Construct(const FArguments& InArgs);
 
    //~ Begin SWidget
    virtual FVector2D ComputeDesiredSize(float LayoutScaleMultiplier) const override;
    //~ End SWidget
 
    //~ Begin SPanel
    virtual void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override;
    virtual FChildren* GetChildren() override { return &Slots; }
    //~ End SPanel
 
    float GetPreferredSize() const { return PreferredSize.Get(); }
    TOptional<float> GetMinLineHeight() const { return MinLineHeight.Get(); }
    float GetLinePadding() const { return LinePadding; }
    bool GetUseGroupedWrapping() const { return bGroupedWrapping; }
 
private:
    TSlateAttribute<float> PreferredSize;
 
    TSlateAttribute<TOptional<float>> MinLineHeight;
 
    float LinePadding;
 
    bool bGroupedWrapping;
 
    TPanelChildren<FSlot> Slots;
 
    TUniquePtr<class UE::Slate::PrioritizedWrapBox::FChildArranger> ChildArranger;
};