SDockTab.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 "Widgets/DeclarativeSyntaxSupport.h"
#include "Styling/SlateColor.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Styling/StyleDefaults.h"
#include "Animation/CurveSequence.h"
#include "Widgets/Layout/SBorder.h"
#include "Framework/Docking/TabManager.h"
 
class FActiveTimerHandle;
class SDockingArea;
class SDockingTabStack;
class SDockingTabWell;
class SImage;
class STextBlock;
class SToolTip;
 
enum ETabRole : uint8
{
    MajorTab,
    PanelTab,
    NomadTab,
    DocumentTab,
    NumRoles
};
 
enum ETabActivationCause : uint8
{
    UserClickedOnTab,
    SetDirectly
};
 
class FMenuBuilder;
 
namespace UE::Slate::Private
{
    class STabPanelDrawer;
}
 
class SDockTab : public SBorder
{
    friend class FTabManager;
    friend class STabSidebar;
    friend UE::Slate::Private::STabPanelDrawer;
 
public:
 
    DECLARE_DELEGATE_OneParam(FOnTabClosedCallback, TSharedRef<SDockTab>);
    
    DECLARE_DELEGATE_TwoParams(FOnTabActivatedCallback, TSharedRef<SDockTab>, ETabActivationCause);
 
    DECLARE_DELEGATE_OneParam(FOnTabRenamed, TSharedRef<SDockTab>);
 
    DECLARE_DELEGATE(FOnPersistVisualState);
 
    DECLARE_DELEGATE_RetVal( bool, FCanCloseTab );
 
    DECLARE_DELEGATE_OneParam(FExtendContextMenu, FMenuBuilder&);
 
    SLATE_BEGIN_ARGS(SDockTab)
        : _Content()
        , _TabWellContentLeft()
        , _TabWellContentRight()
        , _ContentPadding(0.f)
        , _TabRole(ETabRole::PanelTab)
        , _Label()
        , _LabelSuffix()
        , _OnTabClosed()
        , _OnTabActivated()
        , _OnTabRelocated()
        , _OnTabDraggedOverDockArea()
        , _ShouldAutosize(false)
        , _OnCanCloseTab()
        , _CanEverClose(true)
        , _OnPersistVisualState()
        , _TabColorScale(FLinearColor::Transparent)
        , _ForegroundColor(FSlateColor::UseStyle())
        , _IconColor()
        , _LabelOverflowPolicy(ETextOverflowPolicy::Ellipsis)
        {}
 
        SLATE_DEFAULT_SLOT( FArguments, Content )
        SLATE_NAMED_SLOT( FArguments, TabWellContentLeft )
        SLATE_NAMED_SLOT( FArguments, TabWellContentRight )
        SLATE_ATTRIBUTE( FMargin, ContentPadding )
        SLATE_ARGUMENT( ETabRole, TabRole )
        SLATE_ATTRIBUTE( FText, Label )
        SLATE_ATTRIBUTE(FText, LabelSuffix)
        UE_DEPRECATED(5.0, "Tab icons are now being managed by tab spawners and toolkits. In the rare case you need to set an icon manually, use SetTabIcon() instead")
        FArguments& Icon(const FSlateBrush* InIcon)
        {
            return Me();
        }
 
        SLATE_EVENT( FOnTabClosedCallback, OnTabClosed )
        SLATE_EVENT( FOnTabActivatedCallback, OnTabActivated )
        SLATE_EVENT( FSimpleDelegate, OnTabRelocated )
        SLATE_EVENT( FSimpleDelegate, OnTabDraggedOverDockArea )
        SLATE_ARGUMENT( bool, ShouldAutosize )
        SLATE_EVENT( FCanCloseTab, OnCanCloseTab )
        SLATE_ARGUMENT( bool, CanEverClose )
        SLATE_EVENT( FOnPersistVisualState, OnPersistVisualState )
        SLATE_EVENT( FExtendContextMenu, OnExtendContextMenu )
        SLATE_EVENT( FSimpleDelegate, OnTabDrawerClosed)
        SLATE_ATTRIBUTE( FLinearColor, TabColorScale )
        SLATE_ATTRIBUTE( FSlateColor, ForegroundColor )
        SLATE_ATTRIBUTE( FLinearColor, IconColor)
        SLATE_ARGUMENT( ETextOverflowPolicy, LabelOverflowPolicy )
    SLATE_END_ARGS()
 
 
 
    
    SLATE_API void Construct( const FArguments& InArgs );
 
    // SWidget interface
    SLATE_API virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnMouseButtonDoubleClick( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnDragDetected( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent  ) override;
    SLATE_API virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual void OnDragEnter( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent ) override;
    SLATE_API virtual void OnDragLeave( const FDragDropEvent& DragDropEvent ) override;
    SLATE_API virtual FReply OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent ) override;
    SLATE_API virtual FReply OnTouchStarted( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent ) override;
    SLATE_API virtual FReply OnTouchEnded( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent ) override;
    // End of SWidget interface
 
    // SBorder interface
    SLATE_API virtual void SetContent(TSharedRef<SWidget> InContent) override;
    // End of SBorder interface
 
    SLATE_API void SetLeftContent(TSharedRef<SWidget> InContent);
    SLATE_API void SetRightContent(TSharedRef<SWidget> InContent);
    SLATE_API void SetTitleBarRightContent(TSharedRef<SWidget> InContent);
 
    SLATE_API bool IsActive() const;
 
    SLATE_API bool IsForeground() const;
 
    SLATE_API virtual FSlateColor GetForegroundColor() const;
 
    SLATE_API void ExtendContextMenu(FMenuBuilder& MenuBuilder);
 
    SLATE_API ETabRole GetTabRole() const;
 
    SLATE_API ETabRole GetVisualTabRole() const;
 
    SLATE_API const FSlateBrush* GetContentAreaBrush() const;
 
    SLATE_API const FSlateBrush* GetTabWellBrush() const;
 
    SLATE_API TSharedRef<SWidget> GetContent();
    SLATE_API TSharedRef<SWidget> GetLeftContent();
    SLATE_API TSharedRef<SWidget> GetRightContent();
    SLATE_API TSharedRef<SWidget> GetTitleBarRightContent();
 
    SLATE_API FMargin GetContentPadding() const;
 
    SLATE_API const FTabId GetLayoutIdentifier() const;
 
    SLATE_API void SetParent(TSharedPtr<SDockingTabWell> Parent = TSharedPtr<SDockingTabWell>());
 
    void SetParentDockingArea(TSharedPtr<SDockingArea> Parent);
 
    SLATE_API TSharedPtr<SDockingTabWell> GetParent() const;
 
    SLATE_API TSharedPtr<SDockingTabStack> GetParentDockTabStack() const;
 
    SLATE_API TSharedPtr<class SDockingArea> GetDockArea() const;
 
    SLATE_API TSharedPtr<SWindow> GetParentWindow() const;
 
    SLATE_API float GetOverlapWidth() const;
 
    SLATE_API FText GetTabLabel() const;
 
    SLATE_API void SetLabel( const TAttribute<FText>& InTabLabel );
 
    SLATE_API FText GetTabLabelSuffix() const;
 
    SLATE_API void SetTabLabelSuffix(const TAttribute<FText>& InTabLabelSuffix);
 
    SLATE_API void SetTabLabelOverflowPolicy(TOptional<ETextOverflowPolicy> InOverflowPolicy) const;
 
    SLATE_API void SetTabToolTipWidget(TSharedPtr<SToolTip> InTabToolTipWidget);
 
    SLATE_API const FSlateBrush* GetTabIcon() const;
 
    SLATE_API void SetTabIcon( const TAttribute<const FSlateBrush*> InTabIcon );
 
    SLATE_API bool ShouldAutosize() const;
 
    SLATE_API void SetShouldAutosize(const bool bNewShouldAutosize);
 
    SLATE_API bool CanCloseTab() const;
 
    SLATE_API bool CanCloseTab(bool bIgnoreLockedTabs) const;
 
    SLATE_API bool RequestCloseTab();
 
    SLATE_API bool IsTabLocked() const;
 
    SLATE_API void PersistVisualState();
 
    SLATE_API void RemoveTabFromParent();
 
    SLATE_API SDockTab();
 
    SLATE_API void ActivateInParent(ETabActivationCause InActivationCause);
 
    SLATE_API void SetTabManager( const TSharedPtr<FTabManager>& InTabManager );
 
    SLATE_API void SetOnPersistVisualState( const FOnPersistVisualState& Handler );
 
    SLATE_API void SetCanCloseTab( const FCanCloseTab& InOnTabClosing );
 
    SLATE_API void SetOnTabClosed( const FOnTabClosedCallback& InDelegate );
 
    SLATE_API void SetOnTabActivated( const FOnTabActivatedCallback& InDelegate );
 
    SLATE_API void SetOnTabRelocated(const FSimpleDelegate InDelegate);
 
    SLATE_API void SetOnTabDraggedOverDockArea(const FSimpleDelegate InDelegate);
 
    SLATE_API void SetOnTabRenamed(const FOnTabRenamed& InDelegate);
 
    SLATE_API void SetOnTabDrawerOpened(const FSimpleDelegate InDelegate);
 
    SLATE_API void SetOnTabDrawerClosed(const FSimpleDelegate InDelegate);
 
    SLATE_API void SetOnExtendContextMenu( const FExtendContextMenu& Handler );
 
    UE_DEPRECATED(5.0, "The tab manager is not guaranteed to exist, which will cause GetTabManager() to crash. Use GetTabManagerPtr() instead.")
    SLATE_API TSharedRef<FTabManager> GetTabManager() const;
 
    SLATE_API TSharedPtr<FTabManager> GetTabManagerPtr() const;
 
    SLATE_API void DrawAttention();
 
    SLATE_API void ProvideDefaultLabel( const FText& InDefaultLabel );
 
    SLATE_API void PlaySpawnAnim();
 
    SLATE_API void FlashTab();
 
    SLATE_API void SetDraggedOverDockArea( const TSharedPtr<SDockingArea>& Area );
 
    SLATE_API bool HasSiblingTab(const FTabId& SiblingTabId, const bool TreatIndexNoneAsWildcard = true) const;
 
    SLATE_API void UpdateActivationTime();
 
    double GetLastActivationTime()
    {
        return LastActivationTime;
    }
 
    SLATE_API void SetParentDockTabStackTabWellHidden(bool bIsTabWellHidden);
 
    SLATE_API bool IsTabNameHidden() const;
 
protected:
    SLATE_API void ProvideDefaultIcon(const FSlateBrush* InDefaultIcon);
 
    SLATE_API const FDockTabStyle& GetCurrentStyle() const;
 
    SLATE_API const FSlateBrush* GetImageBrush() const;
 
    SLATE_API FMargin GetTabPadding() const;
 
    SLATE_API const FSlateBrush* GetColorOverlayImageBrush() const;
 
    SLATE_API EVisibility GetActiveTabIndicatorVisibility() const;
 
    SLATE_API FSlateColor GetTabColor() const;
 
    SLATE_API FSlateColor GetIconColor() const;
 
    SLATE_API const FSlateBrush* GetFlashOverlayImageBrush() const;
 
    SLATE_API FSlateColor GetFlashColor() const;
 
    SLATE_API FReply OnCloseButtonClicked();
 
    SLATE_API FText GetCloseButtonToolTipText() const;
 
    SLATE_API void SetLayoutIdentifier( const FTabId& TabId );
 
    SLATE_API EVisibility HandleIsCloseButtonVisible() const;
 
    SLATE_API TOptional<FVector2D> GetTabIconSize() const;
 
    SLATE_API FMargin GetTabIconBorderPadding() const;
 
private:
    SLATE_API void SetIsTabNameHidden(bool bInIsTabNameHidden);
 
    SLATE_API EActiveTimerReturnType TriggerActivateTab( double InCurrentTime, float InDeltaTime );
 
    SLATE_API EActiveTimerReturnType OnHandleUpdateStyle(double InCurrentTime, float InDeltaTime);
 
    SLATE_API void OnParentSet();
 
    SLATE_API void UpdateTabStyle();
 
    SLATE_API void OnTabDrawerOpened();
    SLATE_API void OnTabDrawerClosed();
 
    SLATE_API void NotifyTabRelocated();
 
    /* Closes tab if permissions filter no longer allows this tab to be open. */
    SLATE_API void CheckTabAllowed();
 
    void RemoveTabFromParent_Internal();
 
    TWeakPtr<FActiveTimerHandle> DragDropTimerHandle;
    TWeakPtr<FActiveTimerHandle> UpdateStyleTimerHandle;
 
    bool bIsTabNameHidden = false;
protected:
 
    TWeakPtr<FTabManager> MyTabManager;
 
    TSharedRef<SWidget> Content;
    TSharedRef<SWidget> TabWellContentLeft;
    TSharedRef<SWidget> TabWellContentRight;
    TSharedRef<SWidget> TitleBarContentRight;
    
    FTabId LayoutIdentifier;
 
    ETabRole TabRole;
 
    bool bCanEverClose;
 
    TWeakPtr<SDockingTabWell> ParentPtr;
 
    TWeakPtr<SDockingArea> ParentDockingAreaPtr;
 
    TAttribute<FText> TabLabel;
 
    TAttribute<FText> TabLabelSuffix;
 
    TAttribute<const FSlateBrush*> TabIcon;
    
    FOnTabClosedCallback OnTabClosed;
 
    FOnTabActivatedCallback OnTabActivated;
 
    FCanCloseTab OnCanCloseTab;
 
    FSimpleDelegate OnTabDrawerClosedEvent;
 
    FSimpleDelegate OnTabDrawerOpenedEvent;
 
    FSimpleDelegate OnTabRelocated;
 
    FSimpleDelegate OnTabDraggedOverDockArea;
 
    FExtendContextMenu OnExtendContextMenu;
 
    FOnPersistVisualState OnPersistVisualState;
 
    FOnTabRenamed OnTabRenamed;
 
    const FDockTabStyle* MajorTabStyle;
    const FDockTabStyle* GenericTabStyle;
 
    TAttribute<FMargin> ContentAreaPadding;
 
    bool bShouldAutosize;
 
    TAttribute<FLinearColor> TabColorScale;
 
    TAttribute<FLinearColor> IconColor;
 
    SLATE_API UE::Slate::FDeprecateVector2DResult GetAnimatedScale() const;
 
    FCurveSequence SpawnAnimCurve;
 
    FCurveSequence FlashTabCurve;
 
    SLATE_API float GetFlashValue() const;
 
    TSharedPtr<SDockingArea> DraggedOverDockingArea;
 
    TSharedPtr<STextBlock> LabelWidget;
    TSharedPtr<STextBlock> LabelSuffix;
 
    TSharedPtr<SImage> IconWidget;
    
    double LastActivationTime;
};