MultiBoxDefs.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 "Styling/ISlateStyle.h"
#include "Framework/Commands/UICommandInfo.h"
#include "Types/SlateStructs.h"
#include "MultiBoxDefs.generated.h"
 
class SToolTip;
class SWidget;
 
namespace UE::Slate::PrioritizedWrapBox
{
    enum class EWrapMode : uint8
    {
        Preferred = 0,                  // Wraps at the line length specified in PreferredSize
        Parent = 1,                     // Wraps at the wrap box's resulting/actual size
    };
 
    enum class EVerticalOverflowBehavior : uint8
    {
        Clip = 0,                       // Always Clip to the line height as it's been calculated so far, excluding this slots height from affecting the line height
        ExpandProportional = 1,         // Uses the desired height of the slot, maintaining the total area after clamping the width to the available space
 
        Default = Clip,
    };
}
 
UENUM(BlueprintType)
enum class EMultiBoxType : uint8
{
    MenuBar,
 
    ToolBar,
 
    VerticalToolBar,
 
    SlimHorizontalToolBar,
 
    UniformToolBar,
 
    Menu,
 
    ButtonRow,
 
    SlimHorizontalUniformToolBar,
 
    SlimWrappingToolBar,
};
 
 
UENUM(BlueprintType)
enum class EMultiBlockType : uint8
{
    None = 0,
    ButtonRow,
    EditableText,
    Heading,
    MenuEntry,
    Separator,
    ToolBarButton,
    ToolBarComboButton,
    Widget,
};
 
 
class FMultiBoxSettings
{
public:
 
    DECLARE_DELEGATE_RetVal_FourParams( TSharedRef< SToolTip >, FConstructToolTip, const TAttribute<FText>& /*ToolTipText*/, const TSharedPtr<SWidget>& /*OverrideContent*/, const TSharedPtr<const FUICommandInfo>& /*Action*/, bool /*ShowActionShortcut*/);
 
    static SLATE_API TAttribute<bool> UseSmallToolBarIcons;
    static SLATE_API TAttribute<bool> DisplayMultiboxHooks;
    static SLATE_API FConstructToolTip ToolTipConstructor;
    
    static SLATE_API TAttribute<int> MenuSearchFieldVisibilityThreshold;
 
    SLATE_API FMultiBoxSettings();
 
    static SLATE_API TSharedRef< SToolTip > ConstructDefaultToolTip( const TAttribute<FText>& ToolTipText, const TSharedPtr<SWidget>& OverrideContent, const TSharedPtr<const FUICommandInfo>& Action, bool ShowActionShortcut = true );
 
    static SLATE_API void ResetToolTipConstructor();
};
 
struct FMultiBoxCustomization
{
    static SLATE_API const FMultiBoxCustomization None;
 
    static FMultiBoxCustomization AllowCustomization( FName InCustomizationName )
    {
        ensure( InCustomizationName != NAME_None );
        return FMultiBoxCustomization( InCustomizationName );
    }
 
    FName GetCustomizationName() const { return CustomizationName; }
 
    FMultiBoxCustomization( FName InCustomizationName )
        : CustomizationName( InCustomizationName )
    {}
 
private:
    FName CustomizationName;
};
 
namespace EMultiBlockLocation
{
    enum Type
    {
        None = -1,
        
        Start,
 
        Middle,
 
        End,
    };
 
    static FName ToName(FName StyleName, Type InLocation)
    {
        switch(InLocation)
        {
        case Start:
            return ISlateStyle::Join(StyleName, ".Start");
        case Middle:
            return ISlateStyle::Join(StyleName, ".Middle");
        case End:
            return ISlateStyle::Join(StyleName, ".End");
        }
        return StyleName;
    }
 
    static FMargin ToHorizontalMargin(EMultiBoxType InBoxType, Type InLocation, FMargin Margin)
    {
        if (InBoxType == EMultiBoxType::VerticalToolBar || InBoxType == EMultiBoxType::Menu)
        {
            // Vertical groups cut off the tops & bottoms
            switch (InLocation)
            {
            case Start:
                return FMargin(Margin.Left, Margin.Top, Margin.Right, 0.f);
            case Middle:
                return FMargin(Margin.Left, 0.f, Margin.Right, 0.f);
            case End:
                return FMargin(Margin.Left, 0.f, Margin.Right, Margin.Bottom);
            }
            return Margin;
        }
        
        // Horizontal groups cut off the left & right
        switch (InLocation)
        {
        case Start:
            return FMargin(Margin.Left, Margin.Top, 0.f, Margin.Bottom);
        case Middle:
            return FMargin(0.f, Margin.Top, 0.f, Margin.Bottom);
        case End:
            return FMargin(0.f, Margin.Top, Margin.Right, Margin.Bottom);
        }
        return Margin;
    }
}
 
struct FMenuEntryStyleParams
{
    // Workaround for clang deprecation warnings for deprecated members
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FMenuEntryStyleParams() = default;
    FMenuEntryStyleParams(FMenuEntryStyleParams&&) = default;
    FMenuEntryStyleParams(const FMenuEntryStyleParams&) = default;
    FMenuEntryStyleParams& operator=(FMenuEntryStyleParams&&) = default;
    FMenuEntryStyleParams& operator=(const FMenuEntryStyleParams&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    bool bNoIndent = false;
 
    EHorizontalAlignment HorizontalAlignment = HAlign_Fill;
 
    TOptional<EVerticalAlignment> VerticalAlignment;
 
    TOptional<FSizeParam::ESizeRule> SizeRule;
 
    UE_DEPRECATED(5.6, "Use MinimumSize instead")
    TOptional<float> MinSize;
 
    UE_DEPRECATED(5.6, "Use MaximumSize instead")
    TOptional<float> MaxSize;
 
    UE_DEPRECATED(5.6, "Use DesiredWidthOverride instead")
    TOptional<float> DesiredWidth;
 
    UE_DEPRECATED(5.6, "Use DesiredHeightOverride instead")
    TOptional<float> DesiredHeight;
 
    TOptional<float> FillSize;
 
    TOptional<float> FillSizeMin;
 
    TAttribute<float> MinimumSize;
 
    TAttribute<float> MaximumSize;
 
    TAttribute<FOptionalSize> DesiredWidthOverride;
 
    TAttribute<FOptionalSize> DesiredHeightOverride;
};
 
struct FMenuEntryResizeParams
{
    // Keep default values separate from the attributes. This allows the attributes to act like unset optionals by default.
    static constexpr int32 DefaultClippingPriority = 0;
    static constexpr bool DefaultAllowClipping = true;
    static constexpr bool DefaultVisibleInOverflow = true;
 
    TAttribute<int32> ClippingPriority;
 
    TAttribute<bool> AllowClipping;
 
    TAttribute<bool> VisibleInOverflow;
 
    struct FWrappingParams
    {
        // Keep default values separate from the attributes. This allows the attributes to act like unset optionals by default.
        static constexpr bool DefaultAllowWrapping = true;
        static constexpr int32 DefaultPriority = 0;
        static constexpr UE::Slate::PrioritizedWrapBox::EWrapMode DefaultMode = UE::Slate::PrioritizedWrapBox::EWrapMode::Parent;
        static constexpr UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior DefaultVerticalOverflowBehavior = UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior::Default;
        static constexpr bool DefaultForceNewLine = false;
 
        TAttribute<bool> Allow;
 
        TAttribute<int32> Priority;
 
        TAttribute<UE::Slate::PrioritizedWrapBox::EWrapMode> Mode;
 
        TOptional<UE::Slate::PrioritizedWrapBox::EVerticalOverflowBehavior> VerticalOverflowBehavior;
 
        TOptional<bool> ForceNewLine;
    } Wrapping;
};