SDockingTabStack.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Layout/Margin.h"
#include "Layout/Visibility.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Styling/SlateColor.h"
#include "Layout/Geometry.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Animation/CurveSequence.h"
#include "Framework/Docking/TabManager.h"
#include "Framework/Docking/SDockingNode.h"
 
#define DEBUG_TAB_MANAGEMENT 0
 
class FUICommandList;
class FWeakWidgetPath;
class FWidgetPath;
class SDockingTabWell;
class SBorder;
 
template<typename ChildType> class TSlotlessChildren;
 
struct FDockingStackOptionalContent
{
    FDockingStackOptionalContent()
        : ContentLeft(SNullWidget::NullWidget)
        , ContentRight(SNullWidget::NullWidget)
        , TitleBarContentRight(SNullWidget::NullWidget)
    {}
 
    // Content that appears on the left side of tabs in this docking stack
    TSharedRef<SWidget> ContentLeft;
 
    // Content that appears on the right side of tabs in this docking stack
    TSharedRef<SWidget> ContentRight;
 
    // Content that appears on the right side of the title bar in the window this stack is in
    TSharedRef<SWidget> TitleBarContentRight;
};
 
 
class SDockingTabStack : public SDockingNode
{
public:
    SLATE_BEGIN_ARGS(SDockingTabStack)
            : _IsDocumentArea(false) {}
        SLATE_ARGUMENT( bool, IsDocumentArea )
    SLATE_END_ARGS()
 
    virtual Type GetNodeType() const override
    {
        return SDockingNode::DockTabStack;
    }
 
    SLATE_API void OnLastTabRemoved();
 
    SLATE_API void OnTabClosed(const TSharedRef<SDockTab>& ClosedTab, SDockingNode::ELayoutModification RemovalMethod);
 
    SLATE_API void OnTabRemoved( const FTabId& TabId );
 
    SLATE_API void Construct( const FArguments& InArgs, const TSharedRef<FTabManager::FStack>& PersistentNode );
 
    // TabStack methods
 
    SLATE_API void OpenTab(const TSharedRef<SDockTab>& InTab, int32 InsertAtLocation = INDEX_NONE, bool bKeepInactive = false);
 
    SLATE_API void AddTabWidget(const TSharedRef<SDockTab>& InTab, int32 AtLocation = INDEX_NONE, bool bKeepInactive = false);
 
    SLATE_API void AddSidebarTab(const TSharedRef<SDockTab>& InTab);
 
    SLATE_API float GetTabSidebarSizeCoefficient(const TSharedRef<SDockTab>& InTab);
    SLATE_API void SetTabSidebarSizeCoefficient(const TSharedRef<SDockTab>& InTab, float InSizeCoefficient);
 
    SLATE_API bool IsTabPinnedInSidebar(const TSharedRef<SDockTab>& InTab);
    SLATE_API void SetTabPinnedInSidebar(const TSharedRef<SDockTab>& InTab, bool bPinnedInSidebar);
 
    SLATE_API bool IsTabLocked(const TSharedRef<const SDockTab>& InTab) const;
    SLATE_API void SetTabLocked(const TSharedRef<const SDockTab>& InTab, TOptional<bool> bInLocked);
 
    SLATE_API bool CanMoveTabToSideBar(TSharedRef<SDockTab> Tab) const;
 
    SLATE_API void MoveTabToSidebar(TSharedRef<SDockTab> Tab);
 
    SLATE_API void RestoreTabFromSidebar(TSharedRef<SDockTab> Tab);
 
    SLATE_API const TSlotlessChildren<SDockTab>& GetTabs() const;
 
    SLATE_API bool HasTab( const struct FTabMatcher& TabMatcher ) const;
 
    SLATE_API FGeometry GetTabStackGeometry() const;
 
    SLATE_API void RemoveClosedTabsWithName( FName InName );
 
    SLATE_API bool IsShowingLiveTabs() const;
 
    SLATE_API void BringToFront( const TSharedRef<SDockTab>& TabToBringToFront );
 
    SLATE_API void SetNodeContent( const TSharedRef<SWidget>& InContent, const FDockingStackOptionalContent& OptionalContent);
 
    SLATE_API virtual FReply OnUserAttemptingDock( SDockingNode::RelativeDirection Direction, const FDragDropEvent& DragDropEvent ) override;
    
    SLATE_API virtual TArray< TSharedRef<SDockTab> > GetAllChildTabs() const override;
 
    SLATE_API virtual int32 GetNumTabs() const override;
 
    SLATE_API virtual SSplitter::ESizeRule GetSizeRule() const override;
 
    SLATE_API bool CanHideTabWell() const;
 
    
    SLATE_API void SetTabWellHidden( bool bShouldHideTabWell );
    SLATE_API bool IsTabWellHidden() const;
 
    SLATE_API virtual TSharedPtr<FTabManager::FLayoutNode> GatherPersistentLayout() const override;
 
    enum class EChromeElement
    {
        Icon,
        Controls
    };
 
    SLATE_API void ClearReservedSpace();
    SLATE_API void ReserveSpaceForWindowChrome(EChromeElement Element, bool bIncludePaddingForMenuBar, bool bOnlyMinorTabs);
 
public:
    SLATE_API virtual FReply OnDragOver( 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 void OnFocusChanging( const FWeakWidgetPath& PreviousFocusPath, const FWidgetPath& NewWidgetPath, const FFocusEvent& InFocusEvent ) override;
    SLATE_API virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATE_API virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
    virtual bool SupportsKeyboardFocus() const override { return true; }
 
protected:
 
    virtual EWindowZone::Type GetWindowZoneOverride() const override
    {
        // Pretend we are a title bar so the user can grab the area to move the window around
        return EWindowZone::TitleBar;
    }
 
    SLATE_API void CloseForegroundTab();
 
    enum class ETabsToClose : uint8
    {
        CloseDocumentTabs,
        CloseDocumentAndMajorTabs,
        CloseAllTabs
    };
 
    enum class ECloseTabsDirection : uint8
    {
        Left,
        Right
    };
 
    SLATE_API void CloseTabsInDirectionFromForegroundTab(ETabsToClose TabsToClose, ECloseTabsDirection Direction);
 
    SLATE_API void CloseAllButForegroundTab(ETabsToClose TabsToClose);
 
    SLATE_API FReply TabWellRightClicked( const FGeometry& TabWellGeometry, const FPointerEvent& MouseEvent );
 
    SLATE_API virtual SDockingNode::ECleanupRetVal CleanUpNodes() override;
 
    SLATE_API int32 OpenPersistentTab( const FTabId& TabId, int32 OpenLocationAmongActiveTabs = INDEX_NONE );
 
    SLATE_API int32 ClosePersistentTab( const FTabId& TabId );
 
    SLATE_API void RemovePersistentTab( const FTabId& TabId );
 
    SLATE_API virtual void SetParentNode( TSharedRef<class SDockingSplitter> InParent ) override;
 
    bool IsContentEnabled() const;
 
private:
    
    TArray<FTabManager::FTab> Tabs;
 
 
    SLATE_API TSharedRef< SDockingTabStack > CreateNewTabStackBySplitting( const SDockingNode::RelativeDirection Direction );
 
    SLATE_API const FSlateBrush* GetContentAreaBrush() const;
 
    SLATE_API FMargin GetContentPadding() const;
 
    SLATE_API const FSlateBrush* GetTabWellBrush() const;
 
    SLATE_API EVisibility GetTabWellVisibility() const;
 
    SLATE_API EVisibility GetUnhideButtonVisibility() const;
 
    SLATE_API void ToggleTabWellVisibility();
 
    SLATE_API void MoveForegroundTabToSidebar();
 
    SLATE_API FReply UnhideTabWell();
 
    SLATE_API bool CanCloseForegroundTab() const;
 
    static int32 GetIncrementFromCloseTabsDirection(ECloseTabsDirection);
 
    SLATE_API bool CanCloseTabsInDirectionOfForegroundTab(ECloseTabsDirection Direction) const;
 
    SLATE_API bool CanCloseAllButForegroundTab() const;
 
    SLATE_API bool CanMoveForegroundTabToSidebar() const;
 
    SLATE_API bool IsTabAllowedInSidebar(TSharedPtr<SDockTab> Tab) const;
 
    TSharedPtr<class SDockingTabWell> TabWell;
 
    SHorizontalBox::FSlot* InlineContentAreaLeft;
    SHorizontalBox::FSlot* InlineContentAreaRight;
 
    SVerticalBox::FSlot* TitleBarSlot;
    TSharedPtr<SWidget> TitleBarContent;
 
    TSharedPtr<SBorder> ContentSlot;
 
    FOverlayManagement OverlayManagement;
 
    SLATE_API TSharedRef<SWidget> MakeContextMenu();
 
    SLATE_API void ShowCross();
 
    SLATE_API void HideCross();
 
    bool bIsDocumentArea;
 
    FCurveSequence ShowHideTabWell;
 
    SLATE_API FVector2D GetTabWellScale() const;
 
    SLATE_API FVector2D GetUnhideTabWellButtonScale() const;
    SLATE_API FSlateColor GetUnhideTabWellButtonOpacity() const;
 
    SLATE_API const FSlateBrush* GetTabStackBorderImage() const;
 
    SLATE_API EVisibility GetMaximizeSpacerVisibility() const;
 
    SLATE_API void BindTabCommands();
 
    SLATE_API void ExecuteCloseMajorTabCommand();
 
    SLATE_API bool CanExecuteCloseMajorTabCommand();
 
    SLATE_API void ExecuteCloseMinorTabCommand();
 
    SLATE_API bool CanExecuteCloseMinorTabCommand();
 
    SLATE_API void ExecuteCloseFocusedTabCommand();
 
    SLATE_API bool CanExecuteCloseFocusedTabCommand();
 
    SLATE_API virtual void OnResized() override;
 
#if DEBUG_TAB_MANAGEMENT
    SLATE_API FString ShowPersistentTabs() const;
#endif
 
    TSharedPtr<FUICommandList> ActionList;
 
    bool bShowingTitleBarArea;
};
 
 
struct FTabMatcher
{
    FTabMatcher( const FTabId& InTabId, ETabState::Type InTabState = static_cast<ETabState::Type>(ETabState::ClosedTab | ETabState::OpenedTab | ETabState::SidebarTab), const bool InTreatIndexNoneAsWildcard = true )
        : TabIdToMatch( InTabId )
        , RequiredTabState( InTabState )
        , TreatIndexNoneAsWildcard( InTreatIndexNoneAsWildcard )
    {
    }
 
    bool operator()(const FTabManager::FTab& Candidate) const
    {
        return
            ((Candidate.TabState & RequiredTabState) != 0) &&
            (Candidate.TabId.TabType == TabIdToMatch.TabType) &&
            // INDEX_NONE is treated as a wildcard
            ((TreatIndexNoneAsWildcard && TabIdToMatch.InstanceId == INDEX_NONE) || TabIdToMatch.InstanceId == Candidate.TabId.InstanceId);;
    }
 
    FTabId TabIdToMatch;
    ETabState::Type RequiredTabState;
    bool TreatIndexNoneAsWildcard;
};