SSplitter.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 "Widgets/SNullWidget.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "Layout/LayoutGeometry.h"
#include "Widgets/SWidget.h"
#include "SlotBase.h"
#include "Layout/Children.h"
#include "Styling/CoreStyle.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Widgets/SPanel.h"
#include "Styling/SlateTypes.h"
 
#define UE_API SLATE_API
 
class FArrangedChildren;
class FPaintArgs;
class FSlateWindowElementList;
 
namespace ESplitterResizeMode
{
    enum Type
    {
        FixedPosition,
        FixedSize,
        Fill,
    };
}
 
class FLayoutGeometry;
class SSplitter : public SPanel
{
 
public:
    enum ESizeRule
    {
        SizeToContent,
        FractionOfParent
    };
 
    DECLARE_DELEGATE_OneParam(
        FOnSlotResized,
        float );
 
    DECLARE_DELEGATE_RetVal_OneParam(FVector2D, FOnGetMaxSlotSize, int32);
 
public:
    class FSlot : public TSlotBase<FSlot>
    {
    public:     
        FSlot()
            : TSlotBase<FSlot>()
            , SizingRule( FractionOfParent )
            , SizeValue( 1 )
            , MinSizeValue( 0 )
        {
        }
 
        SLATE_SLOT_BEGIN_ARGS(FSlot, TSlotBase<FSlot>)
            SLATE_ATTRIBUTE(ESizeRule, SizeRule)
            SLATE_ATTRIBUTE(float, Value)
            SLATE_ATTRIBUTE(float, MinSize)
            SLATE_ARGUMENT(TOptional<bool>, Resizable)
            SLATE_EVENT(FOnSlotResized, OnSlotResized)
        SLATE_SLOT_END_ARGS()
 
        UE_API void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs);
 
        void SetSizeValue( TAttribute<float> InValue )
        {
            SizeValue = MoveTemp(InValue);
        }
        float GetSizeValue() const
        {
            return SizeValue.Get();
        }
 
        void SetResizable(bool bInIsResizable)
        {
            bIsResizable = bInIsResizable;
        }
        bool IsResizable() const
        {
            return bIsResizable.Get(false);
        }
 
        void SetMinSize(float InMinSize)
        {
            MinSizeValue = InMinSize;
        }
        float GetMinSize() const
        {
            return MinSizeValue.Get(0.f);
        }
        
        FOnSlotResized& OnSlotResized()
        {
            return OnSlotResized_Handler;
        }
        const FOnSlotResized& OnSlotResized() const
        {
            return OnSlotResized_Handler;
        }
 
        void SetSizingRule( TAttribute<ESizeRule> InSizeRule ) 
        {
            SizingRule = MoveTemp(InSizeRule);
        }
        ESizeRule GetSizingRule() const
        {
            return SizingRule.Get();
        }
 
    public:
        UE_API bool CanBeResized() const;
 
    private:
        TAttribute<ESizeRule> SizingRule;
        TAttribute<float> SizeValue;
        TAttribute<float> MinSizeValue;
        FOnSlotResized OnSlotResized_Handler;
        TOptional<bool> bIsResizable;
    };
 
    SLATE_API static FSlot::FSlotArguments Slot();
    
    using FScopedWidgetSlotArguments = TPanelChildren<FSlot>::FScopedWidgetSlotArguments;
    SLATE_API FScopedWidgetSlotArguments AddSlot( int32 AtIndex = INDEX_NONE );
 
    DECLARE_DELEGATE_OneParam(FOnHandleHovered, int32);
 
    SLATE_BEGIN_ARGS(SSplitter)
        : _Style( &FCoreStyle::Get().GetWidgetStyle<FSplitterStyle>("Splitter") )
        , _Orientation( Orient_Horizontal )
        , _ResizeMode( ESplitterResizeMode::FixedPosition )
        , _PhysicalSplitterHandleSize( 5.0f )
        , _HitDetectionSplitterHandleSize( 5.0f )
        , _MinimumSlotHeight( 20.0f )
        , _OnSplitterFinishedResizing()
        {
        }
 
        SLATE_SLOT_ARGUMENT(FSlot, Slots)
 
        
        SLATE_STYLE_ARGUMENT( FSplitterStyle, Style )
 
        SLATE_ARGUMENT( EOrientation, Orientation )
 
        SLATE_ARGUMENT( ESplitterResizeMode::Type, ResizeMode )
 
        SLATE_ARGUMENT( float, PhysicalSplitterHandleSize )
 
        SLATE_ARGUMENT( float, HitDetectionSplitterHandleSize )
 
        SLATE_ARGUMENT( float, MinimumSlotHeight )
 
        SLATE_ATTRIBUTE( int32, HighlightedHandleIndex )
 
        SLATE_EVENT( FOnHandleHovered, OnHandleHovered )
 
        SLATE_EVENT( FSimpleDelegate, OnSplitterFinishedResizing )
        
        SLATE_EVENT( FOnGetMaxSlotSize, OnGetMaxSlotSize )
 
    SLATE_END_ARGS()
 
    SLATE_API SSplitter();
 
    SLATE_API void Construct( const FArguments& InArgs );
 
public:
 
    SLATE_API SSplitter::FSlot& SlotAt( int32 SlotIndex );
 
    SLATE_API int32 RemoveSlot( const TSharedRef<SWidget>& SlotWidget );
 
    SLATE_API void RemoveAt( int32 IndexToRemove );
 
    SLATE_API void ClearChildren();
 
    SLATE_API int32 NumSlots() const;
 
    SLATE_API bool IsValidSlotIndex(int32 Index) const;
 
public:
 
    SLATE_API virtual void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override;
 
 
    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 FVector2D ComputeDesiredSize(float) const override;
 
    SLATE_API virtual FChildren* GetChildren() override;
 
    SLATE_API virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    
    SLATE_API virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
 
    SLATE_API virtual FReply OnMouseButtonDoubleClick(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent) override;
    
    SLATE_API virtual FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
 
    SLATE_API virtual void OnMouseLeave( const FPointerEvent& MouseEvent ) override;
 
    SLATE_API virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) const override;
 
    SLATE_API void SetOrientation( EOrientation NewOrientation );
 
    SLATE_API EOrientation GetOrientation() const;
 
private:
    SLATE_API TArray<FLayoutGeometry> ArrangeChildrenForLayout( const FGeometry& AllottedGeometry ) const;
 
protected:
 
    static SLATE_API int32 FindResizeableSlotBeforeHandle( int32 DraggedHandle, const TPanelChildren<FSlot>& Children );
 
    static SLATE_API int32 FindResizeableSlotAfterHandle( int32 DraggedHandle, const TPanelChildren<FSlot>& Children );
 
    static SLATE_API void FindAllResizeableSlotsAfterHandle( int32 DraggedHandle, const TPanelChildren<FSlot>& Children, TArray<int32, FConcurrentLinearArrayAllocator>& OutSlotIndicies );
 
    SLATE_API void HandleResizingByMousePosition(EOrientation Orientation, const float PhysicalSplitterHandleSize, const ESplitterResizeMode::Type ResizeMode, int32 DraggedHandle, const FVector2D& LocalMousePos, TPanelChildren<FSlot>& Children, const TArray<FLayoutGeometry>& ChildGeometries );
    SLATE_API void HandleResizingDelta(EOrientation Orientation, const float PhysicalSplitterHandleSize, const ESplitterResizeMode::Type ResizeMode, int32 DraggedHandle, float Delta, TPanelChildren<FSlot>& Children, const TArray<FLayoutGeometry>& ChildGeometries);
    SLATE_API void HandleResizingBySize(EOrientation Orientation, const float PhysicalSplitterHandleSize, const ESplitterResizeMode::Type ResizeMode, int32 DraggedHandle, const FVector2D& DesiredSize, TPanelChildren<FSlot>& Children, const TArray<FLayoutGeometry>& ChildGeometries);
 
    SLATE_API float ClampChild(const FSlot& ChildSlot, float ProposedSize) const;
 
    template<EOrientation SplitterOrientation>
    static int32 GetHandleBeingResizedFromMousePosition(  float PhysicalSplitterHandleSize, float HitDetectionSplitterHandleSize, FVector2D LocalMousePos, const TArray<FLayoutGeometry>& ChildGeometries );
 
    TPanelChildren< FSlot > Children;
 
    int32 HoveredHandleIndex;
    TSlateAttribute<int32, EInvalidateWidgetReason::Paint> HighlightedHandleIndex;
    bool bIsResizing;
    EOrientation Orientation;
    ESplitterResizeMode::Type ResizeMode;
 
    FSimpleDelegate OnSplitterFinishedResizing;
    FOnGetMaxSlotSize OnGetMaxSlotSize;
    FOnHandleHovered OnHandleHovered;
 
    float MinSplitterChildLength;
 
    float PhysicalSplitterHandleSize;
    float HitDetectionSplitterHandleSize;
 
    const FSplitterStyle* Style;
};
 
enum class EResizingAxis : uint8
{
    None = 0x00,
    LeftRightMask = 0x01,
    UpDownMask = 0x10,
    CrossMask = UpDownMask | LeftRightMask
};
ENUM_CLASS_FLAGS(EResizingAxis);
 
class SSplitter2x2 : public SPanel
{
private:
    class FSlot : public TSlotBase<FSlot>
    {
    public: 
        SLATE_SLOT_BEGIN_ARGS(FSlot, TSlotBase<FSlot>)
            SLATE_ATTRIBUTE(FVector2D, Percentage)
        SLATE_SLOT_END_ARGS()
 
        
        void SetPercentage( const FVector2D& Value )
        {
            PercentageAttribute.Set( Value );
        }
 
        FVector2D GetPercentage() const
        {
            return PercentageAttribute.Get();
        }
 
        SLATE_API FSlot(const TSharedRef<SWidget>& InWidget);
 
        SLATE_API void Construct(const FChildren& SlotOwner, FSlotArguments&& InArg);
 
    private:
        TAttribute<FVector2D> PercentageAttribute;
    };
 
    SLATE_BEGIN_ARGS( SSplitter2x2 )
        : _Style(&FCoreStyle::Get().GetWidgetStyle<FSplitterStyle>("Splitter"))
        {
        }
        SLATE_STYLE_ARGUMENT(FSplitterStyle, Style)
        SLATE_NAMED_SLOT( FArguments, TopLeft )
        SLATE_NAMED_SLOT( FArguments, BottomLeft )
        SLATE_NAMED_SLOT( FArguments, TopRight )
        SLATE_NAMED_SLOT( FArguments, BottomRight )
    SLATE_END_ARGS()
 
    SLATE_API SSplitter2x2();
 
    SLATE_API void Construct( const FArguments& InArgs );
 
    SLATE_API TSharedRef< SWidget > GetTopLeftContent();
 
    SLATE_API TSharedRef< SWidget > GetBottomLeftContent();
 
    SLATE_API TSharedRef< SWidget > GetTopRightContent();
 
    SLATE_API TSharedRef< SWidget > GetBottomRightContent();
 
    SLATE_API void SetTopLeftContent( TSharedRef< SWidget > TopLeftContent );
 
    SLATE_API void SetBottomLeftContent( TSharedRef< SWidget > BottomLeftContent );
 
    SLATE_API void SetTopRightContent( TSharedRef< SWidget > TopRightContent );
 
    SLATE_API void SetBottomRightContent( TSharedRef< SWidget > BottomRightContent );
 
    SLATE_API void GetSplitterPercentages( TArray< FVector2D >& OutPercentages ) const;
    
    SLATE_API void SetSplitterPercentages( TArrayView< FVector2D > InPercentages );
 
 
private:
 
    TArray<FLayoutGeometry> ArrangeChildrenForLayout( const FGeometry& AllottedGeometry ) const;
 
    SLATE_API virtual void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override;
 
    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 FVector2D ComputeDesiredSize(float) const override;
 
    SLATE_API virtual FChildren* GetChildren() override;
 
    SLATE_API virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    
    SLATE_API virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
 
    SLATE_API virtual FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
 
    SLATE_API virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) const override;
 
    EResizingAxis CalculateResizingAxis( const FGeometry& MyGeometry, const FVector2D& LocalMousePos ) const;
 
    void ResizeChildren( const FGeometry& MyGeometry, const TArray<FLayoutGeometry>& ArrangedChildren, const FVector2D& LocalMousePos );
 
 
private:
 
    TPanelChildren<FSlot> Children;
 
    const FSplitterStyle* Style = nullptr;
 
    EResizingAxis ResizingAxisMask;
 
    bool bIsResizing;
 
    float SplitterHandleSize;
 
    float MinSplitterChildLength;
};
 
#undef UE_API