MultiBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "SlateFwd.h"
#include "Layout/Visibility.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Widgets/Layout/SLinkedBox.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/Layout/SMenuOwner.h"
#include "Widgets/Layout/SUniformWrapPanel.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Commands/UICommandInfo.h"
#include "Framework/Commands/UICommandList.h"
#include "Framework/MultiBox/MultiBoxDefs.h"
 
class FDropPreviewBlock;
class ITableRow;
class SClippingHorizontalBox;
class SHorizontalBox;
class SMultiBoxWidget;
class STableViewBase;
class SVerticalBox;
class UToolMenuBase;
class SUniformWrapPanel;
class FToolBarComboButtonBlock;
 
namespace MultiBoxConstants
{   
    inline const float SubMenuOpenTime = 0.0f;
 
    inline const float SubMenuClobberTime = 0.5f;
 
    inline const float SubMenuClobberMinLifetime = 0.5f;
 
    //inline const FName MenuItemFont = "MenuItem.Font";
    //inline const FName MenuBindingFont = "MenuItem.BindingFont";
 
    //inline const FName EditableTextFont = "MenuItem.Font";
 
    inline const float EditableTextMinWidth = 30.0f;
}
 
class FMultiBlock
    : public TSharedFromThis< FMultiBlock >     // Enables this->AsShared()
{
 
public:
 
    struct FMultiBlockParams
    {
        FUIAction DirectActions;
 
        const TSharedPtr< const FUICommandInfo > Action;
 
        const TSharedPtr< const FUICommandList > ActionList;
 
        FName ExtensionHook;
 
        EMultiBlockType Type = EMultiBlockType::None;
 
        bool bIsPartOfHeading = false;
    };
 
    FMultiBlock( const TSharedPtr< const FUICommandInfo > InCommand, TSharedPtr< const FUICommandList > InCommandList, FName InExtensionHook = NAME_None, EMultiBlockType InType = EMultiBlockType::None, bool bInIsPartOfHeading = false)
        : Action( InCommand )
        , ActionList( InCommandList )
        , ExtensionHook( InExtensionHook )
        , Type( InType )
        , TutorialHighlightName( NAME_None )
        , bSearchable(true)
        , bIsPartOfHeading(bInIsPartOfHeading)
    {
    }
 
    FMultiBlock( const FUIAction& InAction,  FName InExtensionHook = NAME_None, EMultiBlockType InType = EMultiBlockType::None, bool bInIsPartOfHeading = false, TSharedPtr< const FUICommandList > InCommandList = nullptr )
        : DirectActions( InAction )
        , ActionList( InCommandList )
        , ExtensionHook( InExtensionHook )
        , Type( InType )
        , TutorialHighlightName( NAME_None )
        , bSearchable(true)
        , bIsPartOfHeading(bInIsPartOfHeading)
    {
    }
 
    FMultiBlock(const FMultiBlockParams& InMultiBlockParams)
        : DirectActions(InMultiBlockParams.DirectActions)
        , Action(InMultiBlockParams.Action)
        , ActionList(InMultiBlockParams.ActionList)
        , ExtensionHook(InMultiBlockParams.ExtensionHook)
        , Type(InMultiBlockParams.Type)
        , TutorialHighlightName(NAME_None)
        , bSearchable(true)
        , bIsPartOfHeading(InMultiBlockParams.bIsPartOfHeading)
    {
    }
 
    virtual ~FMultiBlock()
    {
    }
 
    TSharedPtr< const FUICommandList > GetActionList() const { return ActionList; }
 
    TSharedPtr< const FUICommandInfo> GetAction() const { return Action; }
 
    const FUIAction& GetDirectActions() const { return DirectActions; }
 
    virtual void CreateMenuEntry(class FMenuBuilder& MenuBuilder) const { }
 
    virtual bool IsGroupStartBlock() const { return false; }
    virtual bool IsGroupEndBlock() const { return false; }
    virtual bool HasIcon() const { return false; }
 
    void SetTutorialHighlightName(FName InTutorialName)
    {
        TutorialHighlightName = InTutorialName;
    }
 
    FName GetTutorialHighlightName() const
    {
        return TutorialHighlightName;
    }
 
    void SetStyleNameOverride(FName InStyleNameOverride)
    {
        StyleNameOverride = InStyleNameOverride;
    }
 
    FName GetStyleNameOverride() const
    {
        return StyleNameOverride;
    }
 
    SLATE_API TSharedRef<class IMultiBlockBaseWidget> MakeWidget(TSharedRef< class SMultiBoxWidget > InOwnerMultiBoxWidget, EMultiBlockLocation::Type InLocation, bool bSectionContainsIcons, TSharedPtr<SWidget> OptionsBlockWidget) const;
 
    const EMultiBlockType GetType() const
    {
        return Type;
    }
 
    bool IsSeparator() const
    {
        return Type == EMultiBlockType::Separator;
    }
 
    bool IsPartOfHeading() const
    {
        return (Type == EMultiBlockType::Heading) || bIsPartOfHeading;
    }
 
    SLATE_API void SetSearchable(bool bSearchable);
 
    SLATE_API bool GetSearchable() const;
 
    FName GetExtensionHook() const { return ExtensionHook; }
 
    TAttribute<EVisibility> GetVisibilityOverride() const;
 
    void SetVisibilityOverride(TAttribute<EVisibility> InVisibilityOverride);
 
    const TAttribute<FMenuEntryResizeParams>& GetResizeParams() const;
 
    void SetResizeParams(const TAttribute<FMenuEntryResizeParams>& InResizeParams);
 
private:
    virtual TSharedRef< class IMultiBlockBaseWidget > ConstructWidget() const = 0;
 
    UE_DEPRECATED(5.5, "Use the version that outputs FMenuEntryStyleParams.")
    virtual bool GetAlignmentOverrides(EHorizontalAlignment& OutHorizontalAlignment, EVerticalAlignment& OutVerticalAlignment, bool& bOutAutoWidth) const { return false; }
 
    virtual bool GetAlignmentOverrides(FMenuEntryStyleParams& OutAlignmentParameters) const { return false; }
private:
 
    // We're friends with SMultiBoxWidget so that it can call MakeWidget() directly
    friend class SMultiBoxWidget;   
 
    FUIAction DirectActions;
 
    const TSharedPtr< const FUICommandInfo > Action;
 
    const TSharedPtr< const FUICommandList > ActionList;
 
    FName ExtensionHook;
 
    EMultiBlockType Type;
 
    FName TutorialHighlightName;
 
    FName StyleNameOverride;
 
    bool bSearchable;
 
    bool bIsPartOfHeading;
 
    TAttribute<EVisibility> VisibilityOverride;
 
    TAttribute<FMenuEntryResizeParams> ResizeParams;
};
 
 
 
 
class FMultiBox
    : public TSharedFromThis< FMultiBox >       // Enables this->AsShared()
{
 
public:
    SLATE_API virtual ~FMultiBox();
 
    static SLATE_API TSharedRef<FMultiBox> Create( const EMultiBoxType InType,  FMultiBoxCustomization InCustomization, const bool bInShouldCloseWindowAfterMenuSelection );
 
    const EMultiBoxType GetType() const
    {
        return Type;
    }
 
    bool ShouldCloseWindowAfterMenuSelection() const
    {
        return bShouldCloseWindowAfterMenuSelection;
    }
 
    int32 GetLastSelectedCommandIndex() const;
    
    void SetLastSelectedCommandIndex( int32 LastSelectedCommandIndex );
 
    SLATE_API void AddMultiBlock( TSharedRef< const FMultiBlock > InBlock );
 
    SLATE_API void AddMultiBlockToFront(TSharedRef< const FMultiBlock > InBlock);
 
    SLATE_API void RemoveCustomMultiBlock( TSharedRef< const FMultiBlock> InBlock );
 
    SLATE_API void InsertCustomMultiBlock( TSharedRef<const FMultiBlock> InBlock, int32 Index );
 
    DECLARE_DELEGATE_TwoParams( FOnMakeMultiBoxBuilderOverride, const TSharedRef<FMultiBox>&, const TSharedRef<SMultiBoxWidget>& );
 
    DECLARE_DELEGATE_RetVal_ThreeParams(TSharedRef<SWidget>, FOnModifyBlockWidgetAfterMake, const TSharedRef<SMultiBoxWidget>&, const FMultiBlock&, const TSharedRef<SWidget>& );
 
    FOnModifyBlockWidgetAfterMake ModifyBlockWidgetAfterMake;
 
    SLATE_API TSharedRef< class SMultiBoxWidget > MakeWidget( bool bSearchable, FOnMakeMultiBoxBuilderOverride* InMakeMultiBoxBuilderOverride = nullptr, TAttribute<float> InMaxHeight = TAttribute<float>() );
 
 
    const TArray< TSharedRef< const FMultiBlock > >& GetBlocks() const
    {
        return Blocks;
    }
    
    const ISlateStyle* GetStyleSet() const { return StyleSet; }
 
    const FName& GetStyleName() const { return StyleName; }
 
    void SetStyle( const ISlateStyle* InStyleSet, const FName& InStyleName )
    {
        StyleSet  = InStyleSet;
        StyleName = InStyleName;
    }
 
    SLATE_API FName GetCustomizationName() const;
 
    SLATE_API TSharedPtr<FMultiBlock> MakeMultiBlockFromCommand( TSharedPtr<const FUICommandInfo> Command, bool bCommandMustBeBound ) const;
 
    SLATE_API TSharedPtr<const FMultiBlock> FindBlockFromNameAndType(const FName InName, const EMultiBlockType InType) const;
 
    SLATE_API bool IsInEditMode() const;
 
    SLATE_API UToolMenuBase* GetToolMenu() const;
 
    SLATE_API int32 GetSectionEditBounds(const int32 Index, int32& OutSectionEndIndex) const;
 
    DECLARE_DELEGATE_OneParam(FEditSelectionChangedDelegate, TSharedRef<const FMultiBlock>);
 
    const FEditSelectionChangedDelegate& OnEditSelectionChanged() const { return EditSelectionChanged; }
 
    FEditSelectionChangedDelegate& OnEditSelectionChanged() { return EditSelectionChanged; }
 
    TWeakObjectPtr<UToolMenuBase> WeakToolMenu;
 
    /* Whether the MultiBox has a search widget */
    bool bHasSearchWidget;
 
    bool bIsFocusable;
 
    TOptional<bool> bAllowWrapButton;
 
    /* Returns the last command list used */
    const TSharedPtr<const FUICommandList> GetLastCommandList() const { return CommandLists.Num() > 0 ? CommandLists.Last() : nullptr; }
 
private:
    
    SLATE_API FMultiBox( const EMultiBoxType InType,  FMultiBoxCustomization InCustomization, const bool bInShouldCloseWindowAfterMenuSelection );
 
    SLATE_API bool IsCustomizable() const;
 
private:
 
    TArray< TSharedPtr<const FUICommandList> > CommandLists;
 
    TArray< TSharedRef< const FMultiBlock > > Blocks;
 
    const ISlateStyle* StyleSet;
 
    FName StyleName;
 
    EMultiBoxType Type;
 
    FEditSelectionChangedDelegate EditSelectionChanged;
 
    bool bShouldCloseWindowAfterMenuSelection;
 
    int32 LastSelectedCommandIndex;
 
};
 
 
 
class IMultiBlockBaseWidget
{
 
public:
 
    virtual TSharedRef<SWidget> AsWidget() = 0;
 
 
    virtual TSharedRef<const SWidget> AsWidget() const = 0;
 
    virtual void SetOwnerMultiBoxWidget(TSharedRef<SMultiBoxWidget> InOwnerMultiBoxWidget ) = 0;
 
    virtual void SetMultiBlock(TSharedRef<const FMultiBlock> InMultiBlock) = 0;
 
    virtual void SetOptionsBlockWidget(TSharedPtr<SWidget> InOptionsBlockWidget) = 0;
 
    virtual void BuildMultiBlockWidget(const ISlateStyle* StyleSet, const FName& StyleName) = 0;
 
    virtual void SetMultiBlockLocation(EMultiBlockLocation::Type InLocation, bool bSectionContainsIcons) = 0;
 
    UE_DEPRECATED(5.6, "Use the const version of GetMultiBlockLocation")
    virtual EMultiBlockLocation::Type GetMultiBlockLocation() = 0;
    
    virtual EMultiBlockLocation::Type GetMultiBlockLocation() const = 0;
 
    virtual bool IsInEditMode() const = 0;
};
 
 
 
class SMultiBlockBaseWidget
    : public IMultiBlockBaseWidget,
      public SCompoundWidget
{
 
public:
    TSharedPtr<const FMultiBlock> GetBlock() const { return MultiBlock; }
 
    SLATE_API virtual TSharedRef< SWidget > AsWidget() override;
    SLATE_API virtual TSharedRef< const SWidget > AsWidget() const override;
    SLATE_API virtual void SetOwnerMultiBoxWidget(TSharedRef<SMultiBoxWidget> InOwnerMultiBoxWidget) override;
    SLATE_API virtual void SetMultiBlock(TSharedRef<const FMultiBlock> InMultiBlock) override;
    SLATE_API virtual void SetOptionsBlockWidget(TSharedPtr<SWidget> InOptionsBlock) override;
    SLATE_API virtual void SetMultiBlockLocation(EMultiBlockLocation::Type InLocation, bool bInSectionContainsIcons) override;
    UE_DEPRECATED(5.6, "Use the const version of GetMultiBlockLocation")
    SLATE_API virtual EMultiBlockLocation::Type GetMultiBlockLocation() override;
    SLATE_API virtual EMultiBlockLocation::Type GetMultiBlockLocation() const override;
    SLATE_API virtual bool IsInEditMode() const override;
 
    SLATE_API virtual void OnDragEnter(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
    SLATE_API virtual FReply OnDragOver(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
    SLATE_API virtual FReply OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
protected:
 
    TWeakPtr<SMultiBoxWidget> OwnerMultiBoxWidget;
 
    TSharedPtr<const FMultiBlock> MultiBlock;
 
    TSharedPtr<SWidget> OptionsBlockWidget;
 
    EMultiBlockLocation::Type Location;
 
    bool bSectionContainsIcons;
};
 
class SMultiBoxWidget
    : public SMenuOwner
{
 
public:
 
    SLATE_BEGIN_ARGS( SMultiBoxWidget )
        : _ContentScale( FVector2D::UnitVector )
        {}
 
        SLATE_ATTRIBUTE( FVector2D, ContentScale )
 
    SLATE_END_ARGS()
 
    
    SLATE_API void Construct( const FArguments& InArgs );
 
    void SetMultiBox( TSharedRef< FMultiBox > InMultiBox )
    {
        MultiBox = InMultiBox;
    }
 
    void SetContent( TSharedRef< SWidget > InContent )
    {   
        ChildSlot
        [
            InContent 
        ];
    }
 
    TSharedRef< const FMultiBox > GetMultiBox() const
    {
        return MultiBox.ToSharedRef();
    }
 
    SLATE_API void SetSearchable(bool bSearchable);
    SLATE_API bool GetSearchable() const;
 
    TSharedRef<FLinkedBoxManager> GetLinkedBoxManager() { return LinkedBoxManager.ToSharedRef(); }
 
    void SetMaxHeight(TAttribute<float> InMaxHeight) { MaxHeight = InMaxHeight; }
 
    SLATE_API void BuildMultiBoxWidget();
 
    SLATE_API void UpdateMultiBoxWidget(TSharedRef<FMultiBox> InMultiBox);
 
    SLATE_API TSharedRef<ITableRow> GenerateTiles(TSharedPtr<SWidget> Item, const TSharedRef<STableViewBase>& OwnerTable);
 
    SLATE_API float GetItemWidth() const;
    SLATE_API float GetItemHeight() const;
 
    SLATE_API TSharedRef<SWidget> OnWrapButtonClicked();
 
    const ISlateStyle* GetStyleSet() const { return MultiBox->GetStyleSet(); }
    const FName& GetStyleName() const { return MultiBox->GetStyleName(); }
 
    SLATE_API void OnCustomCommandDragEnter( TSharedRef<const FMultiBlock> MultiBlock, const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent );
 
    SLATE_API void OnCustomCommandDragged( TSharedRef<const FMultiBlock> MultiBlock, const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent );
 
    SLATE_API void OnCustomCommandDropped();
    
    SLATE_API void OnDropExternal();
 
    static SLATE_API FReply FocusNextWidget(EUINavigation NavigationType);
 
    SLATE_API virtual FReply OnDragOver( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent ) override;
    SLATE_API virtual FReply OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent ) override;
    SLATE_API virtual bool SupportsKeyboardFocus() const override;
    SLATE_API virtual FReply OnFocusReceived( const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent ) override;
    SLATE_API virtual void OnFocusChanging(const FWeakWidgetPath& PreviousFocusPath, const FWidgetPath& NewWidgetPath, const FFocusEvent& InFocusEvent) override;
    SLATE_API virtual FReply OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& KeyEvent ) override;
    SLATE_API virtual FReply OnKeyChar(const FGeometry& MyGeometry, const FCharacterEvent& InCharacterEvent) override;
    SLATE_API virtual bool OnVisualizeTooltip(const TSharedPtr<SWidget>& TooltipContent) override;
 
    SLATE_API void BeginSearch(const TCHAR InChar);
 
    SLATE_API void ResetSearch();
 
    SLATE_API void FilterMultiBoxEntries();
 
    SLATE_API FText GetSearchText() const;
 
    SLATE_API TSharedPtr<SWidget> GetSearchTextWidget();
 
    SLATE_API void SetSearchBlockWidget(TSharedPtr<SWidget>);
 
    UE_DEPRECATED(4.26, "AddSearchElement is deprecated as non-searchable elements also need to be stored, use AddElement instead")
    SLATE_API void AddSearchElement( TSharedPtr<SWidget>, FText );
 
    SLATE_API void AddElement(TSharedPtr<SWidget> BlockWidget, FText BlockDisplayText, bool bInSearchable = true);
 
    SLATE_API bool IsBlockBeingDragged( TSharedPtr<const FMultiBlock> Block ) const;
 
    SLATE_API EVisibility GetCustomizationVisibility(TWeakPtr<const FMultiBlock> BlockWeakPtr, TWeakPtr<SWidget> BlockWidgetWeakPtr) const;
 
    SLATE_API EVisibility GetCustomizationBorderDragVisibility(const FName InBlockName, const EMultiBlockType InBlockType, bool& bOutInsertAfter) const;
 
    SLATE_API void SetSummonedMenuTime(double InSummonedMenuTime);
 
    SLATE_API double GetSummonedMenuTime() const;
 
    UE_DEPRECATED_FORGAME(5.5, "This function will be made private in the future.")
    bool ShouldShowMenuSearchField() const;
 
private:
    SLATE_API void AddBlockWidget(const FMultiBlock& Block, TSharedPtr<SHorizontalBox> HorizontalBox, TSharedPtr<SVerticalBox> VerticalBox, TSharedPtr<SPanel> Panel, EMultiBlockLocation::Type InLocation, bool bSectionContainsIcons, TSharedPtr<const FToolBarComboButtonBlock> OptionsBlock);
 
    SLATE_API void UpdateDropAreaPreviewBlock( TSharedRef<const FMultiBlock> MultiBlock, TSharedPtr<FUICommandDragDropOp> DragDropContent, const FGeometry& DragArea, const FVector2D& DragPos );
 
    SLATE_API void CreateSearchTextWidget();
 
    SLATE_API EVisibility GetSearchBoxVisibility() const;
 
    SLATE_API void OnFilterTextCommitted(const FText& InFilterText, ETextCommit::Type CommitType);
    
    SLATE_API void OnFilterTextChanged(const FText& InFilterText);
 
    SLATE_API void FlattenSubMenusRecursive(uint32 MaxRecursionLevels);
 
private:
    struct FDraggedMultiBlockPreview
    {
        FName BlockName;
        EMultiBlockType BlockType;
        TSharedPtr<class FDropPreviewBlock> PreviewBlock;
        int32 InsertIndex;
        // Vertical for menus and vertical toolbars, horizontally otherwise
        EOrientation InsertOrientation;
 
        FDraggedMultiBlockPreview()
            : BlockType(EMultiBlockType::None)
            , InsertIndex( INDEX_NONE )
        {}
 
        void Reset()
        {
            BlockName = NAME_None;
            BlockType = EMultiBlockType::None;
            PreviewBlock.Reset();
            InsertIndex = INDEX_NONE;
        }
 
        bool IsSameBlockAs(const FName InName, const EMultiBlockType InType) const
        {
            return BlockName == InName && BlockType == InType;
        }
 
        bool IsValid() const { return BlockName != NAME_None && BlockType != EMultiBlockType::None && PreviewBlock.IsValid() && InsertIndex != INDEX_NONE; }
    };
 
    struct FFlattenSearchableBlockInfo
    {
        TArray<FText> SearchableTextHierarchyComponents;
 
        TSharedPtr<SWidget> Widget;
 
        EVisibility HierarchyTipVisibility = EVisibility::Collapsed;
    };
 
    TSharedPtr< FMultiBox > MultiBox;
 
    TArray< TSharedPtr<SWidget> > TileViewWidgets;
 
    TSharedPtr<SHorizontalBox> MainHorizontalBox;
 
    TSharedPtr<SVerticalBox> MainVerticalBox;
 
    TSharedPtr<SPanel> MainPanelBox;
 
    TSharedPtr<class SClippingHorizontalBox> ClippedHorizontalBox;
    
    TSharedPtr<class SClippingVerticalBox> ClippedVerticalBox;
 
    TSharedPtr<SUniformWrapPanel> UniformToolbarPanel;
 
    FDraggedMultiBlockPreview DragPreview;
 
    TMap<TSharedPtr<SWidget>, TArray<FText>> MultiBoxWidgets;
 
    TMap<TSharedPtr<SWidget>, TSharedPtr<const FMultiBlock>> FinalMultiBoxWidgets;
 
    TMap<TSharedPtr<const FMultiBlock>, TSharedPtr<FFlattenSearchableBlockInfo>> FlattenSearchableBlocks;
 
    bool bDidFlattenSearchableBlocks = false;
 
    TMap<TSharedPtr<SWidget>, TSharedPtr<FFlattenSearchableBlockInfo>> FlattenSearchableWidgets;
 
    TSet<FString> VisibleFlattenHierarchyTips;
 
    /* The search widget to be displayed at the top of the multibox */
    TSharedPtr<SSearchBox> SearchTextWidget;
 
    /* The search widget to be displayed at the top of the multibox */
    TSharedPtr<SWidget> SearchBlockWidget;
 
    /* The text being searched for */
    FText SearchText;
 
    bool bSearchable;
 
    double SummonedMenuTime = 0.0;
 
    TAttribute<float> MaxHeight;
 
    TSharedPtr<FLinkedBoxManager> LinkedBoxManager;
};