SBreadcrumbTrail.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/SlateColor.h"
#include "Layout/Visibility.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Layout/Margin.h"
#include "Widgets/SNullWidget.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/SBoxPanel.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Input/SMenuAnchor.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Layout/SScrollBox.h"
 
// Base class for breadcrumb trail holding methods which are not dependent on the crumb data type.
class SBreadcrumbTrailBase : public SCompoundWidget
{
public:
    SLATE_API void ScrollToStart();
    SLATE_API void ScrollToEnd();
 
protected:
    TSharedPtr<SScrollBox> CrumbBox;
};
 
template <typename ItemType>
class SBreadcrumbTrail : public SBreadcrumbTrailBase
{
private:
    struct FCrumbItem
    {
        int32 CrumbID;
        TSharedRef<SButton> Button;
        TSharedRef<SMenuAnchor> Delimiter;
        TSharedRef<SVerticalBox> ButtonBox;
        TSharedRef<SVerticalBox> DelimiterBox;
        ItemType CrumbData;
 
        FCrumbItem(int32 InCrumbID, TSharedRef<SButton> InButton, TSharedRef<SMenuAnchor> InDelimiter, TSharedRef<SVerticalBox> InButtonBox, TSharedRef<SVerticalBox> InDelimiterBox, ItemType InCrumbData)
            : CrumbID(InCrumbID)
            , Button(InButton)
            , Delimiter(InDelimiter)
            , ButtonBox(InButtonBox)
            , DelimiterBox(InDelimiterBox)
            , CrumbData(InCrumbData)
        {}
    };
 
public:
    DECLARE_DELEGATE_OneParam( FOnCrumbPushed, const ItemType& /*CrumbData*/ );
 
    DECLARE_DELEGATE_OneParam( FOnCrumbPopped, const ItemType& /*CrumbData*/ );
 
    DECLARE_DELEGATE_OneParam( FOnCrumbClicked, const ItemType& /*CrumbData*/ );
 
    DECLARE_DELEGATE_RetVal_OneParam( bool, FHasCrumbMenuContent, const ItemType& /*CrumbData*/ );
 
    DECLARE_DELEGATE_RetVal_OneParam( TSharedRef< SWidget >, FGetCrumbMenuContent, const ItemType& /*CrumbData*/ );
 
    DECLARE_DELEGATE_RetVal_TwoParams( TSharedRef<SWidget>, FGetCrumbButtonContent, const ItemType& /*CrumbData*/, const FTextBlockStyle* InTextStyle );    
 
    SLATE_BEGIN_ARGS( SBreadcrumbTrail )
        : _ButtonStyle( &FCoreStyle::Get().GetWidgetStyle< FButtonStyle >( "BreadcrumbButton" ) )
        , _TextStyle( &FCoreStyle::Get().GetWidgetStyle<FTextBlockStyle>("NormalText") )
        , _ButtonContentPadding(FMargin(4.0, 2.0))
        , _DelimiterImage( FCoreStyle::Get().GetBrush("BreadcrumbTrail.Delimiter") )
        , _ShowLeadingDelimiter(false)
        , _PersistentBreadcrumbs(false)
        , _HasCrumbMenuContent()
        , _GetCrumbMenuContent()
        {}
 
        SLATE_STYLE_ARGUMENT( FButtonStyle, ButtonStyle )
        
        
        SLATE_STYLE_ARGUMENT( FTextBlockStyle, TextStyle )
 
        
        SLATE_ATTRIBUTE( FMargin, ButtonContentPadding )
 
        
        SLATE_ATTRIBUTE( const FSlateBrush*, DelimiterImage )
 
        
        SLATE_ATTRIBUTE( bool, ShowLeadingDelimiter )
 
        
        SLATE_EVENT( FOnCrumbPushed, OnCrumbPushed )
 
        
        SLATE_EVENT( FOnCrumbPopped, OnCrumbPopped )
 
        
        SLATE_EVENT( FOnCrumbClicked, OnCrumbClicked )
 
        
        SLATE_ARGUMENT( bool, PersistentBreadcrumbs )
 
        SLATE_EVENT( FHasCrumbMenuContent, HasCrumbMenuContent )
 
        SLATE_EVENT( FGetCrumbMenuContent, GetCrumbMenuContent )
 
        SLATE_EVENT( FGetCrumbButtonContent, GetCrumbButtonContent )
 
    SLATE_END_ARGS()
 
    
    void Construct( const FArguments& InArgs )
    {
        ButtonStyle = InArgs._ButtonStyle;
        TextStyle = InArgs._TextStyle;
        ButtonContentPadding = InArgs._ButtonContentPadding;
        DelimiterImage = InArgs._DelimiterImage;
        ShowLeadingDelimiter = InArgs._ShowLeadingDelimiter;
        OnCrumbPushed = InArgs._OnCrumbPushed;
        OnCrumbPopped = InArgs._OnCrumbPopped;
        OnCrumbClicked = InArgs._OnCrumbClicked;
        bHasStaticBreadcrumbs = InArgs._PersistentBreadcrumbs;
        HasCrumbMenuContentCallback = InArgs._HasCrumbMenuContent;
        GetCrumbMenuContentCallback = InArgs._GetCrumbMenuContent;
        GetCrumbButtonContentCallback = InArgs._GetCrumbButtonContent;
 
        NextValidCrumbID = 0;
 
        ChildSlot
        [
            SAssignNew(CrumbBox, SScrollBox)
            .Orientation(Orient_Horizontal)
            .ScrollBarVisibility(EVisibility::Collapsed)
        ];
 
        AddLeadingDelimiter();
    }
 
    void PushCrumb(const TAttribute<FText>& CrumbText, const ItemType& NewCrumbData)
    {
        // Create the crumb and add it to the crumb box
        TSharedPtr<SButton> NewButton;
        TSharedPtr<SMenuAnchor> NewDelimiter;
 
        TSharedPtr<SVerticalBox> NewButtonBox;
        TSharedPtr<SVerticalBox> NewDelimiterBox;
 
        TSharedRef<SWidget> ContentWidget = GetCrumbButtonContentCallback.IsBound() ? GetCrumbButtonContentCallback.Execute(NewCrumbData, TextStyle) : SNullWidget::NullWidget; 
 
        // Add the crumb button
        CrumbBox->AddSlot()
        [
            SAssignNew(NewButtonBox, SVerticalBox)
 
            +SVerticalBox::Slot()
            .FillHeight( 1.0f )
            [
                // Crumb Button
                SAssignNew(NewButton, SButton)
                .ButtonStyle(ButtonStyle)
                .ContentPadding(ButtonContentPadding)
                .TextStyle(TextStyle)
                .Text(CrumbText)
                .OnClicked( this, &SBreadcrumbTrail::CrumbButtonClicked, NextValidCrumbID )
                .Content()
                [
                    ContentWidget
                ]
            ]
        ];
 
        TSharedRef< SWidget > DelimiterContent = SNullWidget::NullWidget;
        if ( GetCrumbMenuContentCallback.IsBound() )
        {
            // Crumb Arrow
            DelimiterContent = SNew(SButton)
                .VAlign(EVerticalAlignment::VAlign_Center)
                .ButtonStyle(ButtonStyle)
                .Visibility(this, &SBreadcrumbTrail::GetCrumbDelimiterVisibility, NextValidCrumbID)
                .OnClicked(this, &SBreadcrumbTrail::OnCrumbDelimiterClicked, NextValidCrumbID)
                .ContentPadding(FMargin(3, 0))
                [
                    SNew(SImage)
                    .Image(DelimiterImage)
                    .ColorAndOpacity(FSlateColor::UseForeground())
                ];
        }
        else
        {
            DelimiterContent = SNew(SButton)
                .VAlign(EVerticalAlignment::VAlign_Center)
                .ButtonStyle(ButtonStyle)
                .Visibility( this, &SBreadcrumbTrail::GetDelimiterVisibility, NextValidCrumbID )
                .ContentPadding( FMargin(3, 0) )
                [
                    SNew(SImage)
                    .Image(DelimiterImage)
                    .ColorAndOpacity(FSlateColor::UseForeground())
                ];
        }
 
        CrumbBox->AddSlot()
        [
            SAssignNew(NewDelimiterBox, SVerticalBox)
 
            +SVerticalBox::Slot()
            .FillHeight(1.0f)
            [
                SAssignNew( NewDelimiter, SMenuAnchor )
                .OnGetMenuContent( this, &SBreadcrumbTrail::GetCrumbMenuContent, NextValidCrumbID )
                [
                    DelimiterContent
                ]
            ]
        ];
 
        // Push the crumb data
        CrumbList.Emplace(NextValidCrumbID, NewButton.ToSharedRef(), NewDelimiter.ToSharedRef(), NewButtonBox.ToSharedRef(), NewDelimiterBox.ToSharedRef(), NewCrumbData);
 
        // Increment the crumb ID for the next crumb
        NextValidCrumbID = (NextValidCrumbID + 1) % (INT_MAX - 1);
 
        // Trigger event
        OnCrumbPushed.ExecuteIfBound(NewCrumbData);
 
        // We've added a new crumb so defer scrolling to the end to next tick
        CrumbBox->ScrollToEnd();
    }
 
    ItemType PopCrumb()
    {
        check(HasCrumbs());
 
        // Remove from the crumb list and box
        const FCrumbItem& LastCrumbItem = CrumbList.Pop();
 
        CrumbBox->RemoveSlot(LastCrumbItem.ButtonBox);
        CrumbBox->RemoveSlot(LastCrumbItem.DelimiterBox);
 
        // Trigger event
        OnCrumbPopped.ExecuteIfBound(LastCrumbItem.CrumbData);
 
        // Return the popped crumb's data
        return LastCrumbItem.CrumbData;
    }
 
    ItemType PeekCrumb() const
    {
        check(HasCrumbs());
 
        // Return the last crumb's text
        return CrumbList.Last().CrumbData;
    }
 
    bool HasCrumbs() const
    {
        return NumCrumbs() > 0;
    }
 
    int32 NumCrumbs() const
    {
        return CrumbList.Num();
    }
 
    void ClearCrumbs(bool bPopAllCrumbsToClear = false)
    {
        if (bPopAllCrumbsToClear)
        {
            while ( HasCrumbs() )
            {
                PopCrumb();
            }
        }
        else
        {
            CrumbBox->ClearChildren();
            CrumbList.Empty();
            
            AddLeadingDelimiter();
        }
    }
 
    void GetAllCrumbData(TArray<ItemType>& CrumbData) const
    {
        for (int32 CrumbIdx = 0; CrumbIdx < NumCrumbs(); ++CrumbIdx)
        {
            CrumbData.Add(CrumbList[CrumbIdx].CrumbData);
        }
    }
 
private:
 
    EVisibility GetCrumbDelimiterVisibility(int32 CrumbID) const
    {
        if (HasCrumbs() && CrumbList.Last().CrumbID == CrumbID && HasCrumbMenuContentCallback.IsBound() && !HasCrumbMenuContentCallback.Execute(CrumbList.Last().CrumbData))
        {
            return EVisibility::Collapsed;
        }
        return EVisibility::Visible;
    }
 
    FReply OnCrumbDelimiterClicked( int32 CrumbID )
    {
        FReply Reply = FReply::Unhandled();
 
        if ( GetCrumbMenuContentCallback.IsBound() )
        {
            for (int32 CrumbListIdx = 0; CrumbListIdx < NumCrumbs(); ++CrumbListIdx)
            {
                if (CrumbList[CrumbListIdx].CrumbID == CrumbID)
                {
                    CrumbList[CrumbListIdx].Delimiter->SetIsOpen( true );
                    Reply = FReply::Handled();
                    break;
                }
            }
        }
 
        return Reply;
    }
 
    TSharedRef< SWidget > GetCrumbMenuContent( int32 CrumbId )
    {
        if ( !GetCrumbMenuContentCallback.IsBound() )
        {
            return SNullWidget::NullWidget;
        }
 
        TSharedPtr< SWidget > MenuContent;
 
        for (int32 CrumbListIdx = 0; CrumbListIdx < NumCrumbs(); ++CrumbListIdx)
        {
            if (CrumbList[CrumbListIdx].CrumbID == CrumbId)
            {
                if (HasCrumbMenuContentCallback.IsBound() )
                {
                    if (!HasCrumbMenuContentCallback.Execute( CrumbList[CrumbListIdx].CrumbData ))
                    {
                        return SNullWidget::NullWidget;
                    }
                }
 
                MenuContent = GetCrumbMenuContentCallback.Execute( CrumbList[CrumbListIdx].CrumbData );
                break;
            }
        }
 
        return MenuContent.ToSharedRef();
    }
 
    EVisibility GetDelimiterVisibility(int32 CrumbID) const
    {
        if ( HasCrumbs() && CrumbList.Last().CrumbID == CrumbID )
        {
            // Collapse the last delimiter
            return EVisibility::Collapsed;
        }
 
        return EVisibility::Visible;
    }
 
    EVisibility GetLeadingDelimiterVisibility() const
    {
        return ShowLeadingDelimiter.Get() ? EVisibility::Visible : EVisibility::Collapsed;
    }
 
    FReply CrumbButtonClicked(int32 CrumbID)
    {
        int32 CrumbIdx = INDEX_NONE;
 
        if (bHasStaticBreadcrumbs)
        {
            for (int32 CrumbListIdx = 0; CrumbListIdx < NumCrumbs(); ++CrumbListIdx)
            {
                if (CrumbList[CrumbListIdx].CrumbID == CrumbID)
                {
                    OnCrumbClicked.ExecuteIfBound(CrumbList[CrumbListIdx].CrumbData);
                    break;
                }
            }
        }
        else
        {
            for (int32 CrumbListIdx = 0; CrumbListIdx < NumCrumbs(); ++CrumbListIdx)
            {
                if (CrumbList[CrumbListIdx].CrumbID == CrumbID)
                {
                    CrumbIdx = CrumbListIdx;
                    break;
                }
            }
 
            if ( CrumbIdx != INDEX_NONE )
            {
                while (NumCrumbs() - 1 > CrumbIdx)
                {
                    PopCrumb();
                }
 
                OnCrumbClicked.ExecuteIfBound(CrumbList.Last().CrumbData);
            }
        }
        return FReply::Handled();
    }
 
    void AddLeadingDelimiter()
    {
        CrumbBox->AddSlot()
        .VAlign(VAlign_Center)
        [
            SNew(SImage)
            .Image(DelimiterImage)
            .Visibility( this, &SBreadcrumbTrail::GetLeadingDelimiterVisibility )
        ];
    }
 
private:
 
    TArray<FCrumbItem> CrumbList;
 
    int32 NextValidCrumbID;
 
    const FButtonStyle* ButtonStyle;
 
    const FTextBlockStyle* TextStyle;
 
    TAttribute<FMargin> ButtonContentPadding;
 
    TAttribute< const FSlateBrush* > DelimiterImage;
 
    FOnCrumbPushed OnCrumbPushed;
 
    FOnCrumbPopped OnCrumbPopped;
 
    FOnCrumbClicked OnCrumbClicked;
 
    FHasCrumbMenuContent HasCrumbMenuContentCallback;
 
    FGetCrumbMenuContent GetCrumbMenuContentCallback;
 
    FGetCrumbButtonContent GetCrumbButtonContentCallback;
 
    TAttribute<bool> ShowLeadingDelimiter;
 
    bool bHasStaticBreadcrumbs;
 
};