SBoxPanel.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/Margin.h"
#include "Layout/Visibility.h"
#include "Types/SlateStructs.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "SlotBase.h"
#include "Widgets/SWidget.h"
#include "Layout/BasicLayoutWidgetSlot.h"
#include "Layout/Children.h"
#include "Widgets/SPanel.h"
#include "Layout/ArrangedChildren.h"
#include "Input/DragAndDrop.h"
#include "Rendering/DrawElements.h"
#include "Styling/SlateBrush.h"
 
class FArrangedChildren;
 
template <>
struct TWidgetTypeTraits<class SBoxPanel>
{
    static constexpr bool SupportsInvalidation() { return true; }
};
 
 
class SBoxPanel : public SPanel
{
    SLATE_DECLARE_WIDGET_API(SBoxPanel, SPanel, SLATECORE_API)
 
protected:
    template<typename SlotType>
    class TSlot : public TBasicLayoutWidgetSlot<SlotType>, public TResizingWidgetSlotMixin<SlotType>
    {
    public:
        SLATE_SLOT_BEGIN_ARGS_OneMixin(TSlot, TBasicLayoutWidgetSlot<SlotType>, TResizingWidgetSlotMixin<SlotType>)
        SLATE_SLOT_END_ARGS()
 
    protected:
        TSlot()
            : TBasicLayoutWidgetSlot<SlotType>(HAlign_Fill, VAlign_Fill)
            , TResizingWidgetSlotMixin<SlotType>()
        {
        }
 
    public:
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            TBasicLayoutWidgetSlot<SlotType>::Construct(SlotOwner, MoveTemp(InArgs));
            TResizingWidgetSlotMixin<SlotType>::ConstructMixin(SlotOwner, MoveTemp(InArgs));
        }
 
        static void RegisterAttributes(FSlateWidgetSlotAttributeInitializer& AttributeInitializer)
        {
            TBasicLayoutWidgetSlot<SlotType>::RegisterAttributes(AttributeInitializer);
            TResizingWidgetSlotMixin<SlotType>::RegisterAttributesMixin(AttributeInitializer);
        }
    };
 
public:
    class FSlot : public TSlot<FSlot>
    {
    };
 
protected:
    template<typename SlotType>
    struct FScopedWidgetSlotArguments : public SlotType::FSlotArguments
    {
    public:
        FScopedWidgetSlotArguments(TUniquePtr<SlotType> InSlot, TPanelChildren<FSlot>& InChildren, int32 InIndex)
            : SlotType::FSlotArguments(MoveTemp(InSlot))
            , Children(InChildren)
            , Index(InIndex)
        {
        }
 
        FScopedWidgetSlotArguments() = delete;
        FScopedWidgetSlotArguments(const FScopedWidgetSlotArguments&) = delete;
        FScopedWidgetSlotArguments& operator=(const FScopedWidgetSlotArguments&) = delete;
        FScopedWidgetSlotArguments(FScopedWidgetSlotArguments&&) = default;
        FScopedWidgetSlotArguments& operator=(FScopedWidgetSlotArguments&&) = default;
 
        virtual ~FScopedWidgetSlotArguments()
        {
            if (this->GetSlot())    // Is nullptr when the FScopedWidgetSlotArguments is moved-constructed.
            {
                SBoxPanel::FSlot::FSlotArguments* SelfAsBaseSlot = static_cast<SBoxPanel::FSlot::FSlotArguments*>(static_cast<FSlotBase::FSlotArguments*>(this));
                if (Index == INDEX_NONE)
                {
                    Children.AddSlot(MoveTemp(*SelfAsBaseSlot));
                }
                else
                {
                    Children.InsertSlot(MoveTemp(*SelfAsBaseSlot), Index);
                }
            }
        }
 
    private:
        TPanelChildren<FSlot>& Children;
        int32 Index;
    };
 
public:
    SLATECORE_API int32 RemoveSlot( const TSharedRef<SWidget>& SlotWidget );
 
    SLATECORE_API void ClearChildren();
 
    int32 NumSlots() const { return Children.Num(); }
 
    bool IsValidSlotIndex(int32 Index) const { return Children.IsValidIndex(Index); }
 
    //~ Begin SWidget overrides.
public:
    SLATECORE_API virtual void OnArrangeChildren(const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren) const override;
    SLATECORE_API virtual FChildren* GetChildren() override;
 
protected:
    SLATECORE_API virtual FVector2D ComputeDesiredSize(float) const override;
    //~ End SWidget overrides.
 
protected:
    SLATECORE_API SBoxPanel();
    SLATECORE_API SBoxPanel(EOrientation InOrientation);
    SLATECORE_API ~SBoxPanel();
 
    SLATECORE_API void SetOrientation(EOrientation InOrientation);
    EOrientation GetOrientation() const
    {
        return Orientation;
    }
 
protected:
    TPanelChildren<FSlot> Children;
 
    EOrientation Orientation;
};
 
 
template <>
struct TWidgetTypeTraits<class SHorizontalBox>
{
    static constexpr bool SupportsInvalidation() { return true; }
};
 
class SHorizontalBox : public SBoxPanel
{
    SLATE_DECLARE_WIDGET_API(SHorizontalBox, SBoxPanel, SLATECORE_API)
public:
    class FSlot : public SBoxPanel::TSlot<FSlot>
    {
    public:
        SLATE_SLOT_BEGIN_ARGS(FSlot, SBoxPanel::TSlot<FSlot>)
            FSlotArguments& AutoWidth()
            {
                _SizeParam = FAuto();
                return Me();
            }
        
            FSlotArguments& FillWidth(TAttribute<float> InStretchCoefficient)
            {
                _SizeParam = FStretch(MoveTemp(InStretchCoefficient));
                return Me();
            }
        
            FSlotArguments& FillContentWidth(TAttribute<float> InStretchCoefficient, TAttribute<float> InShrinkStretchCoefficient = TAttribute<float>())
            {
                _SizeParam = FStretchContent(MoveTemp(InStretchCoefficient), MoveTemp(InShrinkStretchCoefficient));
                return Me();
            }
 
            FSlotArguments& MinWidth(TAttribute<float> InMinWidth)
            {
                _MinSize = MoveTemp(InMinWidth);
                return Me();
            }
 
            FSlotArguments& MaxWidth(TAttribute<float> InMaxWidth)
            {
                _MaxSize = MoveTemp(InMaxWidth);
                return Me();
            }
        SLATE_SLOT_END_ARGS()
 
        
        void SetAutoWidth()
        {
            SetSizeToAuto();
        }
 
        void SetFillWidth(TAttribute<float> InStretchCoefficient)
        {
            SetSizeToStretch(MoveTemp(InStretchCoefficient));
        }
 
        void SetFillContentWidth(TAttribute<float> InStretchCoefficient, TAttribute<float> InShrinkStretchCoefficient = TAttribute<float>())
        {
            SetSizeToStretchContent(MoveTemp(InStretchCoefficient), MoveTemp(InShrinkStretchCoefficient));
        }
 
        void SetMinWidth(TAttribute<float> InMinWidth)
        {
            SetMinSize(MoveTemp(InMinWidth));
        }
 
        void SetMaxWidth(TAttribute<float> InMaxWidth)
        {
            SetMaxSize(MoveTemp(InMaxWidth));
        }
 
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            SBoxPanel::TSlot<FSlot>::Construct(SlotOwner, MoveTemp(InArgs));
        }
    };
 
    static FSlot::FSlotArguments Slot()
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>());
    }
 
    SLATE_BEGIN_ARGS( SHorizontalBox )
    {
        _Visibility = EVisibility::SelfHitTestInvisible;
    }
        SLATE_SLOT_ARGUMENT(SHorizontalBox::FSlot, Slots)
    SLATE_END_ARGS()
 
    using FScopedWidgetSlotArguments = SBoxPanel::FScopedWidgetSlotArguments<SHorizontalBox::FSlot>;
    FScopedWidgetSlotArguments AddSlot()
    {
        return InsertSlot(INDEX_NONE);
    }
 
    FScopedWidgetSlotArguments InsertSlot(int32 Index = INDEX_NONE)
    {
        return FScopedWidgetSlotArguments(MakeUnique<FSlot>(), this->Children, Index);
    }
 
    SLATECORE_API FSlot& GetSlot(int32 SlotIndex);
    SLATECORE_API const FSlot& GetSlot(int32 SlotIndex) const;
 
    FORCENOINLINE SHorizontalBox()
        : SBoxPanel( Orient_Horizontal )
    {
        SetCanTick(false);
        bCanSupportFocus = false;
    }
 
    SLATECORE_API void Construct( const FArguments& InArgs );
};
 
 
template <>
struct TWidgetTypeTraits<class SVerticalBox>
{
    static constexpr bool SupportsInvalidation() { return true; }
};
 
class SVerticalBox : public SBoxPanel
{
    SLATE_DECLARE_WIDGET_API(SVerticalBox, SBoxPanel, SLATECORE_API)
public:
    class FSlot : public SBoxPanel::TSlot<FSlot>
    {
    public:
        SLATE_SLOT_BEGIN_ARGS(FSlot, SBoxPanel::TSlot<FSlot>)
        
            
            FSlotArguments& AutoHeight()
            {
                _SizeParam = FAuto();
                return Me();
            }
        
            FSlotArguments& FillHeight(TAttribute<float> InStretchCoefficient)
            {
                _SizeParam = FStretch(MoveTemp(InStretchCoefficient));
                return Me();
            }
        
            FSlotArguments& FillContentHeight(TAttribute<float> InStretchCoefficient, TAttribute<float> InShrinkStretchCoefficient = TAttribute<float>())
            {
                _SizeParam = FStretchContent(MoveTemp(InStretchCoefficient), MoveTemp(InShrinkStretchCoefficient));
                return Me();
            }
 
            FSlotArguments& MinHeight(TAttribute<float> InMinHeight)
            {
                _MinSize = MoveTemp(InMinHeight);
                return Me();
            }
            
            FSlotArguments& MaxHeight(TAttribute<float> InMaxHeight)
            {
                _MaxSize = MoveTemp(InMaxHeight);
                return Me();
            }
        SLATE_SLOT_END_ARGS()
 
        
        void SetAutoHeight()
        {
            SetSizeToAuto();
        }
 
        void SetFillHeight(TAttribute<float> InStretchCoefficient)
        {
            SetSizeToStretch(MoveTemp(InStretchCoefficient));
        }
 
        void SetFillContentHeight(TAttribute<float> InStretchCoefficient, TAttribute<float> InShrinkStretchCoefficient = TAttribute<float>())
        {
            SetSizeToStretchContent(MoveTemp(InStretchCoefficient), MoveTemp(InShrinkStretchCoefficient));
        }
 
        void SetMinHeight(TAttribute<float> InMinHeight)
        {
            SetMinSize(MoveTemp(InMinHeight));
        }
 
        void SetMaxHeight(TAttribute<float> InMaxHeight)
        {
            SetMaxSize(MoveTemp(InMaxHeight));
        }
 
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            SBoxPanel::TSlot<FSlot>::Construct(SlotOwner, MoveTemp(InArgs));
        }
    };
 
    static FSlot::FSlotArguments Slot()
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>());
    }
 
 
    SLATE_BEGIN_ARGS( SVerticalBox )
    {
        _Visibility = EVisibility::SelfHitTestInvisible;
    }
        SLATE_SLOT_ARGUMENT(SVerticalBox::FSlot, Slots)
    SLATE_END_ARGS()
 
    using FScopedWidgetSlotArguments = SBoxPanel::FScopedWidgetSlotArguments<SVerticalBox::FSlot>;
    FScopedWidgetSlotArguments AddSlot()
    {
        return InsertSlot(INDEX_NONE);
    }
 
    FScopedWidgetSlotArguments InsertSlot(int32 Index = INDEX_NONE)
    {
        return FScopedWidgetSlotArguments(MakeUnique<FSlot>(), this->Children, Index);
    }
 
    SLATECORE_API FSlot& GetSlot(int32 SlotIndex);
    SLATECORE_API const FSlot& GetSlot(int32 SlotIndex) const;
 
    FORCENOINLINE SVerticalBox()
        : SBoxPanel( Orient_Vertical )
    {
        SetCanTick(false);
        bCanSupportFocus = false;
    }
 
    SLATECORE_API void Construct( const FArguments& InArgs );
};
 
 
template <>
struct TWidgetTypeTraits<class SStackBox>
{
    static constexpr bool SupportsInvalidation() { return true; }
};
 
class SStackBox : public SBoxPanel
{
    SLATE_DECLARE_WIDGET_API(SStackBox, SBoxPanel, SLATECORE_API)
public:
    class FSlot : public SBoxPanel::TSlot<FSlot>
    {
    public:
        SLATE_SLOT_BEGIN_ARGS(FSlot, SBoxPanel::TSlot<FSlot>)
            FSlotArguments& AutoSize()
            {
                _SizeParam = FAuto();
                return Me();
            }
 
            FSlotArguments& FillSize(TAttribute<float> InStretchCoefficient)
            {
                _SizeParam = FStretch(MoveTemp(InStretchCoefficient));
                return Me();
            }
 
            FSlotArguments& FillContentSize(TAttribute<float> InStretchCoefficient, TAttribute<float> InShrinkStretchCoefficient = TAttribute<float>())
            {
                _SizeParam = FStretchContent(MoveTemp(InStretchCoefficient), MoveTemp(InShrinkStretchCoefficient));
                return Me();
            }
 
            FSlotArguments& MinSize(TAttribute<float> InMinHeight)
            {
                _MinSize = MoveTemp(InMinHeight);
                return Me();
            }
 
            FSlotArguments& MaxSize(TAttribute<float> InMaxHeight)
            {
                _MaxSize = MoveTemp(InMaxHeight);
                return Me();
            }
        SLATE_SLOT_END_ARGS()
 
        void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
        {
            SBoxPanel::TSlot<FSlot>::Construct(SlotOwner, MoveTemp(InArgs));
        }
    };
 
    static FSlot::FSlotArguments Slot()
    {
        return FSlot::FSlotArguments(MakeUnique<FSlot>());
    }
 
 
    SLATE_BEGIN_ARGS(SStackBox)
    {
        _Visibility = EVisibility::SelfHitTestInvisible;
    }
        SLATE_ARGUMENT(EOrientation, Orientation)
        SLATE_SLOT_ARGUMENT(SStackBox::FSlot, Slots)
    SLATE_END_ARGS()
 
    using FScopedWidgetSlotArguments = SBoxPanel::FScopedWidgetSlotArguments<SStackBox::FSlot>;
    FScopedWidgetSlotArguments AddSlot()
    {
        return InsertSlot(INDEX_NONE);
    }
 
    FScopedWidgetSlotArguments InsertSlot(int32 Index = INDEX_NONE)
    {
        return FScopedWidgetSlotArguments(MakeUnique<FSlot>(), this->Children, Index);
    }
 
    SLATECORE_API FSlot& GetSlot(int32 SlotIndex);
    SLATECORE_API const FSlot& GetSlot(int32 SlotIndex) const;
 
    FORCENOINLINE SStackBox()
    {
        SetCanTick(false);
        bCanSupportFocus = false;
    }
 
    SLATECORE_API void Construct(const FArguments& InArgs);
 
    using SBoxPanel::SetOrientation;
    using SBoxPanel::GetOrientation;
};
 
class FDragAndDropVerticalBoxOp : public FDragDropOperation
{
public:
    DRAG_DROP_OPERATOR_TYPE(FDragAndDropVerticalBoxOp, FDragDropOperation)
 
    
    int32 SlotIndexBeingDragged;
    SVerticalBox::FSlot* SlotBeingDragged;
 
    virtual ~FDragAndDropVerticalBoxOp()
    {}
};
 
class SDragAndDropVerticalBox : public SVerticalBox
{
public:
    enum class EItemDropZone
    {
        AboveItem,
        BelowItem
    };
 
    DECLARE_DELEGATE_RetVal_FourParams(FReply, FOnDragAndDropVerticalBoxDragDetected, const FGeometry&, const FPointerEvent&, int32, SVerticalBox::FSlot*)
    DECLARE_DELEGATE_OneParam(FOnDragAndDropVerticalBoxDragEnter, FDragDropEvent const&);
    DECLARE_DELEGATE_OneParam(FOnDragAndDropVerticalBoxDragLeave, FDragDropEvent const&);
    DECLARE_DELEGATE_RetVal_OneParam(FReply, FOnDragAndDropVerticalBoxDrop, FDragDropEvent const&);
 
    UE_DEPRECATED(5.6, "FOnCanAcceptDrop is deprecated. Please use FOnCanAcceptDropAdvanced which adds the drop slot index parameter.")
    DECLARE_DELEGATE_RetVal_ThreeParams(TOptional<EItemDropZone>, FOnCanAcceptDrop, const FDragDropEvent&, SDragAndDropVerticalBox::EItemDropZone, SVerticalBox::FSlot*);
    DECLARE_DELEGATE_RetVal_FourParams(TOptional<EItemDropZone>, FOnCanAcceptDropAdvanced, const FDragDropEvent&, SDragAndDropVerticalBox::EItemDropZone, int32, SVerticalBox::FSlot*);
    DECLARE_DELEGATE_RetVal_FourParams(FReply, FOnAcceptDrop, const FDragDropEvent&, SDragAndDropVerticalBox::EItemDropZone, int32, SVerticalBox::FSlot*);
 
    SLATE_BEGIN_ARGS(SDragAndDropVerticalBox)
        {}
 
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        FOnCanAcceptDropAdvanced ConvertCanAcceptDropFn(const FOnCanAcceptDrop& LegacyDelegate)
        {
            return FOnCanAcceptDropAdvanced::CreateLambda([LegacyDelegate](const FDragDropEvent& Event, SDragAndDropVerticalBox::EItemDropZone DropZone, int32 SlotIndex, SVerticalBox::FSlot* Slot)
                {
                    if (LegacyDelegate.IsBound())
                    {
                        return LegacyDelegate.Execute(Event, DropZone, Slot);
                    }
 
                    return TOptional<EItemDropZone>();
                });
        }
 
        SLATE_EVENT_DEPRECATED(5.6, "Use FOnCanAcceptDropAdvanced instead", FOnCanAcceptDrop, OnCanAcceptDrop, OnCanAcceptDropAdvanced, ConvertCanAcceptDropFn)
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
        SLATE_EVENT(FOnCanAcceptDropAdvanced, OnCanAcceptDropAdvanced)
 
        
        SLATE_EVENT(FOnAcceptDrop, OnAcceptDrop)
 
        // Low level DragAndDrop
        SLATE_EVENT(FOnDragAndDropVerticalBoxDragDetected, OnDragDetected)
        SLATE_EVENT(FOnDragAndDropVerticalBoxDragEnter, OnDragEnter)
        SLATE_EVENT(FOnDragAndDropVerticalBoxDragLeave, OnDragLeave)
        SLATE_EVENT(FOnDragAndDropVerticalBoxDrop, OnDrop)
    SLATE_END_ARGS()
 
    SLATECORE_API void Construct(const FArguments& InArgs);
 
    SDragAndDropVerticalBox& SetDropIndicator_Above(const FSlateBrush& InValue) { DropIndicator_Above = InValue; return *this; }
    SDragAndDropVerticalBox& SetDropIndicator_Below(const FSlateBrush& InValue) { DropIndicator_Below = InValue; return *this; }
 
    SLATECORE_API virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
        
    SLATECORE_API virtual FReply OnDragDetected(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
    SLATECORE_API virtual void OnDragEnter(FGeometry const& MyGeometry, FDragDropEvent const& DragDropEvent) override;
    SLATECORE_API virtual void OnDragLeave(FDragDropEvent const& DragDropEvent) override;
    SLATECORE_API virtual FReply OnDragOver(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
    SLATECORE_API virtual FReply OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
 
    SLATECORE_API virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
 
private:
    FOnCanAcceptDropAdvanced OnCanAcceptDropAdvanced;
 
    FOnAcceptDrop OnAcceptDrop;
 
    TOptional<EItemDropZone> ItemDropZone;
 
    FOnDragAndDropVerticalBoxDragDetected OnDragDetected_Handler;
 
    FOnDragAndDropVerticalBoxDragEnter OnDragEnter_Handler;
 
    FOnDragAndDropVerticalBoxDragLeave OnDragLeave_Handler;
 
    FOnDragAndDropVerticalBoxDrop OnDrop_Handler;
 
    FSlateBrush DropIndicator_Above;
    FSlateBrush DropIndicator_Below;
 
    FVector2f CurrentDragOperationScreenSpaceLocation;
    int32 CurrentDragOverSlotIndex;
 
    SLATECORE_API EItemDropZone ZoneFromPointerPosition(FVector2f LocalPointerPos, const FGeometry& CurrentGeometry, const FGeometry& StartGeometry) const;
};