TabManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "SlateFwd.h"
#include "Containers/Ticker.h"
#include "Containers/ContainersFwd.h"
#include "Misc/Attribute.h"
#include "Textures/SlateIcon.h"
#include "Widgets/SWindow.h"
#include "Framework/Docking/WorkspaceItem.h"
#include "Framework/Commands/UIAction.h"
#include "Templates/Function.h"
 
class FJsonObject;
class FMenuBuilder;
class FNamePermissionList;
class FMultiBox;
class FProxyTabmanager;
class SDockingArea;
class SDockingTabStack;
class FLayoutExtender;
struct FTabMatcher;
struct FSidebarTabLists;
 
namespace UE::Editor::HomeScreen
{
    inline bool IsHomeScreenEnabled()
    {
        static bool bIsHomeScreenEnabled = false;
        UE_CALL_ONCE([&]()
        {
            if (const IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("HomeScreen.EnableHomeScreen")))
            {
                ensureAlwaysMsgf(!EnumHasAnyFlags(CVar->GetFlags(), ECVF_Default), TEXT("The CVar should have already been set from commandline."));
                bIsHomeScreenEnabled = CVar->GetBool();
            }
        });
        return bIsHomeScreenEnabled;
    }
}
 
DECLARE_MULTICAST_DELEGATE_TwoParams(
    FOnActiveTabChanged,
    TSharedPtr<SDockTab>,
    TSharedPtr<SDockTab> );
    
 
enum class ESidebarLocation : uint8
{
    Left,
    Right,
 
    None,
};
 
 
enum class ETabIdFlags : uint8
{
    None            = 0x0,  // No flags
    SaveLayout      = 0x1,  // This tab should be included when saving the Slate layout
};
 
ENUM_CLASS_FLAGS(ETabIdFlags);
 
struct FTabId
{
    FTabId()
        : InstanceId(INDEX_NONE)
        , Flags(ETabIdFlags::SaveLayout)
    { }
 
    FTabId(const FName InTabType, const int32 InInstanceId)
        : TabType(InTabType)
        , InstanceId(InInstanceId)
        , Flags(ETabIdFlags::SaveLayout)
    { }
 
    FTabId(const FName InTabType)
        : TabType(InTabType)
        , InstanceId(INDEX_NONE)
        , Flags(ETabIdFlags::SaveLayout)
    { }
 
    FTabId(const FName InTabType, const ETabIdFlags InFlags)
        : TabType(InTabType)
        , InstanceId(INDEX_NONE)
        , Flags(InFlags)
    { }
 
    bool IsTabPersistable() const
    {
        return InstanceId == INDEX_NONE;
    }
 
    bool operator==(const FTabId& Other) const
    {
        return TabType == Other.TabType && (InstanceId == INDEX_NONE || Other.InstanceId == INDEX_NONE || InstanceId == Other.InstanceId) ;
    }
 
    bool ShouldSaveLayout() const { return EnumHasAnyFlags(Flags, ETabIdFlags::SaveLayout); }
 
    FString ToString() const
    {
        // This function is useful to allow saving the layout on disk.
        // Alternative: We could save (InstanceId == INDEX_NONE) ? TabType.ToString() : FString::Printf( TEXT("%s : %d"), *(TabType.ToString()), InstanceId ), which would include the InstanceId.
        // Problem: InstanceId depends on the Editor/Slate runtime session rather than the layout itself. I.e., this would lead to the exact same layout being saved differently, depending
        // on how many tabs were opened/closed before arriving to that final layout, or in the order in which those tabs were created.
        // Conclusion: We do not want to save the InstanceId, which is session-dependent rather than layout-dependent.
        // More detailed explanation: When the Editor is opened, InstanceId is a static value starting in 0 and increasing every time a new FTabID is created (but not decreased when one is
        // closed). Loading/saving layouts do not reset this number either (and there is no point in doing so given that it is a runtime variable). E.g., opening and closing the same tab
        // multiple times will lead to higher InstanceId numbers in the final layout. In addition, creating tab A and then B would lead to A::InstanceId = 0, B::InstanceId = 1. While creating
        // B first and A latter would lead to the opposite values. Any of these examples would wrongly make 2 exact layouts look "different" if we saved the InstanceIds.
        return TabType.ToString();
    }
 
    FText ToText() const
    {
        FFormatNamedArguments Args;
        Args.Add( TEXT("TabType"), FText::FromName( TabType ) );
        Args.Add( TEXT("InstanceIdNumber"), FText::AsNumber( InstanceId ) );
 
        return (InstanceId == INDEX_NONE)
            ? FText::FromName( TabType )
            : FText::Format( NSLOCTEXT("TabManager", "TabIdFormat", "{TabType} : {InstanceIdNumber}"), Args );
    }
 
    friend uint32 GetTypeHash(const FTabId& In)
    {
        return GetTypeHash(In.TabType) ^ In.InstanceId;
    }
 
    FName TabType;
    int32 InstanceId;
 
    private:
    ETabIdFlags Flags;
};
 
 
class FSpawnTabArgs
{
public:
    FSpawnTabArgs( const TSharedPtr<SWindow>& InOwnerWindow, const FTabId& InTabBeingSpawenedId )
    : TabIdBeingSpawned(InTabBeingSpawenedId)
    , OwnerWindow(InOwnerWindow)
    {
    }
 
    const TSharedPtr<SWindow>& GetOwnerWindow() const
    {
        return OwnerWindow;
    }
 
    const FTabId& GetTabId() const 
    {
        return TabIdBeingSpawned;
    }
 
private:
    FTabId TabIdBeingSpawned;
    TSharedPtr<SWindow> OwnerWindow;
};
 
 
DECLARE_DELEGATE_RetVal_OneParam( TSharedRef<SDockTab>, FOnSpawnTab, const FSpawnTabArgs& );
DECLARE_DELEGATE_RetVal_OneParam(bool, FCanSpawnTab, const FSpawnTabArgs&);
DECLARE_DELEGATE_RetVal_OneParam( TSharedPtr<SDockTab>, FOnFindTabToReuse, const FTabId& )
 
struct FMinorTabConfig
{
public:
    FMinorTabConfig()
    {
    }
 
    FMinorTabConfig(const FName& InTabID)
        : TabId(InTabID)
    {
    }
 
    FName TabId;
 
    FText TabLabel;
 
    FText TabTooltip;
 
    FSlateIcon TabIcon;
 
    FOnSpawnTab OnSpawnTab;
 
    FCanSpawnTab CanSpawnTab;
 
    FOnFindTabToReuse OnFindTabToReuse;
 
    TSharedPtr<FWorkspaceItem> WorkspaceGroup;
};
 
namespace ETabSpawnerMenuType
{
    enum Type
    {
        Enabled,        // Display this spawner in menus
        Disabled,       // Display this spawner in menus, but make it disabled
        Hidden,         // Do not display this spawner in menus, it will be invoked manually
    };
}
 
enum class ETabReadOnlyBehavior : int32
{
    Disabled, // Default behavior - This tab will show up in read only modes but the contents will be disabled
    Hidden,   // This tab will not show up in read only modes
    Custom    // This tab will show up in read only modes and the tab owner will decide how it behaves (FTabManager::OnReadOnlyStateChanged to keep track of read only state)
};
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnReadOnlyModeChanged, bool /*bReadOnly*/);
 
struct FTabSpawnerEntry : public FWorkspaceItem
{
    FTabSpawnerEntry(const FName& InTabType, const FOnSpawnTab& InSpawnTabMethod, const FCanSpawnTab& InCanSpawnTab)
        : FWorkspaceItem(InTabType, FText(), FSlateIcon(), false)
        , TabType(InTabType)
        , OnSpawnTab(InSpawnTabMethod)
        , CanSpawnTab(InCanSpawnTab)
        , OnFindTabToReuse()
        , MenuType(ETabSpawnerMenuType::Enabled)
        , bAutoGenerateMenuEntry(true)
        , bCanSidebarTab(true)
        , bHiddenTabName(false)
        , SpawnedTabPtr()
        , ReadOnlyBehavior(ETabReadOnlyBehavior::Disabled)
    {
        // Special treatment for the HomeScreen tab to not have its name displayed and to be locked, this is currently intended to not be a public feature
        if (InTabType == FName(TEXT("HomeScreen")))
        {
            bHiddenTabName = true;
            bIsLocked = true;
        }
 
        // Special treatment for the LevelEditor tab to be locked, this is currently intended to not be a public feature
        if (InTabType == FName(TEXT("LevelEditor")))
        {
            bIsLocked = true;
        }
    }
 
    FTabSpawnerEntry& SetReadOnlyBehavior( const ETabReadOnlyBehavior& InReadOnlyBehavior)
    {
        ReadOnlyBehavior = InReadOnlyBehavior;
        return *this;
    }
    
    FTabSpawnerEntry& SetIcon( const FSlateIcon& InIcon)
    {
        Icon = InIcon;
        return *this;
    }
 
    FTabSpawnerEntry& SetDisplayNameAttribute(const TAttribute<FText>& InLegibleName)
    {
        DisplayNameAttribute = InLegibleName;
        return *this;
    }
 
    FTabSpawnerEntry& SetTooltipTextAttribute(const TAttribute<FText>& InTooltipText)
    {
        TooltipTextAttribute = InTooltipText;
        return *this;
    }
 
    FTabSpawnerEntry& SetDisplayName( const FText& InLegibleName )
    {
        DisplayNameAttribute = InLegibleName;
        return *this;
    }
 
    FTabSpawnerEntry& SetTooltipText( const FText& InTooltipText )
    {
        TooltipTextAttribute = InTooltipText;
        return *this;
    }
 
    FTabSpawnerEntry& SetGroup( const TSharedRef<FWorkspaceItem>& InGroup )
    {
        InGroup->AddItem(SharedThis(this));
        return *this;
    }
 
    FTabSpawnerEntry& SetReuseTabMethod( const FOnFindTabToReuse& InReuseTabMethod )
    {
        OnFindTabToReuse = InReuseTabMethod;
        return *this;
    }
 
    FTabSpawnerEntry& SetMenuType( const TAttribute<ETabSpawnerMenuType::Type>& InMenuType )
    {
        MenuType = InMenuType;
        return *this;
    }
 
    FTabSpawnerEntry& SetAutoGenerateMenuEntry( bool bInAutoGenerateMenuEntry )
    {
        bAutoGenerateMenuEntry = bInAutoGenerateMenuEntry;
        return *this;
    }
 
    FTabSpawnerEntry& SetCanSidebarTab(bool bInCanSidebarTab)
    {
        bCanSidebarTab = bInCanSidebarTab;
        return *this;
    }
 
    bool CanSidebarTab() const
    {
        return bCanSidebarTab;
    }
 
    TOptional<bool> IsTabLocked() const
    {
        return bIsLocked;
    }
 
    bool IsTabNameHidden() const
    {
        return bHiddenTabName;
    }
 
    virtual TSharedPtr<FTabSpawnerEntry> AsSpawnerEntry() override
    {
        return SharedThis(this);
    }
 
    const FName GetTabType() const
    {
        return TabType;
    };
 
    const bool IsHidden() const
    {
        return MenuType.Get() == ETabSpawnerMenuType::Hidden;
    }
 
private:
    FName TabType;
    FOnSpawnTab OnSpawnTab;
    FCanSpawnTab CanSpawnTab;
    FOnFindTabToReuse OnFindTabToReuse;
    TAttribute<ETabSpawnerMenuType::Type> MenuType;
    bool bAutoGenerateMenuEntry;
    bool bCanSidebarTab;
    bool bHiddenTabName;
    TOptional<bool> bIsLocked;
 
    TWeakPtr<SDockTab> SpawnedTabPtr;
 
    ETabReadOnlyBehavior ReadOnlyBehavior;
 
    FORCENOINLINE bool IsSoleTabInstanceSpawned() const
    {
        // Items that allow multiple instances need a custom way to find and reuse tabs.
        return SpawnedTabPtr.IsValid();
    }
 
    friend class FTabManager;
};
 
 
namespace ETabState
{
    enum Type
    {
        OpenedTab = 0x1 << 0,
        ClosedTab = 0x1 << 1,
        SidebarTab = 0x1 << 2,
 
        InvalidTab = 0x1 << 3
    };
}
 
enum class EOutputCanBeNullptr
{
    Never,
    IfNoTabValid,
    IfNoOpenTabValid
};
 
 
class FTabManager : public TSharedFromThis<FTabManager>
{
    friend class FGlobalTabmanager;
    public:
 
        class FStack;
        class FSplitter;
        class FArea;
        class FLayout;
 
        DECLARE_DELEGATE_OneParam( FOnPersistLayout, const TSharedRef<FLayout>& );
 
        class FLayoutNode : public TSharedFromThis<FLayoutNode>
        {
            friend class FTabManager;
 
        public:
 
            virtual ~FLayoutNode() { }
            
            SLATE_API virtual TSharedPtr<FStack> AsStack();
 
            SLATE_API virtual TSharedPtr<FSplitter> AsSplitter();
 
            SLATE_API virtual TSharedPtr<FArea> AsArea();
 
            float GetSizeCoefficient() const { return SizeCoefficient; }
 
        protected:
            FLayoutNode()
            : SizeCoefficient(1.0f)
            {
            }
 
            float SizeCoefficient;
        };
 
        struct FTab
        {
            FTab(const FTabId& InTabId, ETabState::Type InTabState)
                : TabId(InTabId)
                , TabState(InTabState)
                , SidebarLocation(ESidebarLocation::None)
                , SidebarSizeCoefficient(0.0f)
                , bPinnedInSidebar(false)
                , bIsLockedInPlace(TOptional<bool>())
            {
                check(InTabState != ETabState::SidebarTab);
            }
 
            FTab(const FTabId& InTabId, ETabState::Type InTabState, ESidebarLocation InSidebarLocation, float InSidebarSizeCoefficient, bool bInPinnedInSidebar)
                : TabId(InTabId)
                , TabState(InTabState)
                , SidebarLocation(InSidebarLocation)
                , SidebarSizeCoefficient(InSidebarSizeCoefficient)
                , bPinnedInSidebar(bInPinnedInSidebar)
                , bIsLockedInPlace(TOptional<bool>())
            {
                check(InTabState != ETabState::SidebarTab || InSidebarLocation != ESidebarLocation::None);
            }
 
            bool operator==( const FTab& Other ) const
            {
                return this->TabId == Other.TabId && this->TabState == Other.TabState && this->SidebarLocation == Other.SidebarLocation;
            }
 
            FTabId TabId;
            ETabState::Type TabState;
            ESidebarLocation SidebarLocation;
            float SidebarSizeCoefficient;
            bool bPinnedInSidebar;
            TOptional<bool> bIsLockedInPlace;
        };
 
        class FStack : public FLayoutNode
        {
                friend class FTabManager;
                friend class FLayout;
                friend class SDockingTabStack;
 
            public:             
                TSharedRef<FStack> AddTab(const FName TabType, ETabState::Type InTabState)
                {
                    check(InTabState != ETabState::SidebarTab);
                    Tabs.Add(FTab( FTabId(TabType), InTabState));
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> AddTab(const FTabId TabId, ETabState::Type InTabState)
                {
                    check(InTabState != ETabState::SidebarTab);
 
                    Tabs.Add(FTab(TabId, InTabState));
 
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> AddTab(const FName TabType, ETabState::Type InTabState, ESidebarLocation InSidebarLocation, float SidebarSizeCoefficient, bool bPinnedInSidebar=false)
                {
                    check(InTabState != ETabState::SidebarTab || InSidebarLocation != ESidebarLocation::None);
                    Tabs.Add(FTab(FTabId(TabType), InTabState, InSidebarLocation, SidebarSizeCoefficient, bPinnedInSidebar));
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> AddTab(const FTabId TabId, ETabState::Type InTabState, ESidebarLocation InSidebarLocation, float SidebarSizeCoefficient, bool bPinnedInSidebar=false)
                {
                    check(InTabState != ETabState::SidebarTab || InSidebarLocation != ESidebarLocation::None);
 
                    Tabs.Add(FTab(TabId, InTabState, InSidebarLocation, SidebarSizeCoefficient, bPinnedInSidebar));
 
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> AddTab(const FTab& Tab)
                {
                    Tabs.Add(Tab);
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> SetSizeCoefficient( const float InSizeCoefficient )
                {
                    SizeCoefficient = InSizeCoefficient;
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> SetHideTabWell( const bool InHideTabWell )
                {
                    bHideTabWell = InHideTabWell;
                    return SharedThis(this);
                }
 
                TSharedRef<FStack> SetForegroundTab( const FTabId& TabId )
                {
                    ForegroundTabId = TabId;
                    return SharedThis(this);
                }
 
                virtual TSharedPtr<FStack> AsStack() override
                {
                    return SharedThis(this);
                }
 
                virtual ~FStack()
                {
                }
 
                TSharedRef<FStack> SetExtensionId(FName InExtensionId)
                {
                    ExtensionId = InExtensionId;
                    return SharedThis(this);
                }
 
                FName GetExtensionId() const
                {
                    return ExtensionId;
                }
 
                TConstArrayView<FTab> GetTabs() const
                {
                    return Tabs;
                }
 
            protected:
 
                FStack()
                : Tabs()
                , bHideTabWell(false)
                , ForegroundTabId(NAME_None)
                {
                }
 
                TArray<FTab> Tabs;
                bool bHideTabWell;
                FTabId ForegroundTabId;
                FName ExtensionId;
        };
 
 
        class FSplitter : public FLayoutNode
        {
                friend class FTabManager;
                friend class FLayoutExtender;
        
            public:
 
                TSharedRef<FSplitter> Split( TSharedRef<FLayoutNode> InNode )
                {
                    ChildNodes.Add(InNode);
                    return SharedThis(this);
                }
 
                TSharedRef<FSplitter> InsertBefore(TSharedRef<FLayoutNode> NodeToInsertBefore, TSharedRef<FLayoutNode> NodeToInsert)
                {
                    int32 InsertAtIndex = ChildNodes.Find(NodeToInsertBefore);
                    check(InsertAtIndex != INDEX_NONE);
                    ChildNodes.Insert(NodeToInsert, InsertAtIndex);
                    return SharedThis(this);
                }
 
                TSharedRef<FSplitter> InsertAfter(TSharedRef<FLayoutNode> NodeToInsertAfter, TSharedRef<FLayoutNode> NodeToInsert)
                {
                    int32 InsertAtIndex = ChildNodes.Find(NodeToInsertAfter);
                    check(InsertAtIndex != INDEX_NONE);
                    ChildNodes.Insert(NodeToInsert, InsertAtIndex + 1);
                    return SharedThis(this);
                }
 
 
                TSharedRef<FSplitter> SetSizeCoefficient( const float InSizeCoefficient )
                {
                    SizeCoefficient = InSizeCoefficient;
                    return SharedThis(this);
                }
 
                TSharedRef<FSplitter> SetOrientation( const EOrientation InOrientation )
                {
                    Orientation = InOrientation;
                    return SharedThis(this);
                }
 
                virtual TSharedPtr<FSplitter> AsSplitter() override
                {
                    return SharedThis(this);
                }
 
                EOrientation GetOrientation() const { return Orientation; }
 
                virtual ~FSplitter()
                {
                }
 
                TConstArrayView<TSharedRef<FLayoutNode>> GetChildNodes() const
                {
                    return ChildNodes;
                }
 
            protected:
                FSplitter()
                : Orientation(Orient_Horizontal)
                {
                }
 
                EOrientation Orientation;
                TArray< TSharedRef<FLayoutNode> > ChildNodes;
        };
 
        struct FPanelDrawerSize
        {
            float MainContentCoefficient = 0.75f;
            float PanelDrawerCoefficient = 0.25f;
        };
 
        struct FPanelDrawerTab
        {
            FTabId TabId;
            FPanelDrawerSize Size;
        };
 
        class FArea : public FSplitter
        {
                friend class FTabManager;
        
            public:
                enum EWindowPlacement
                {
                    Placement_NoWindow,
 
                    Placement_Automatic,
 
                    Placement_Specified
                };
 
                TSharedRef<FArea> Split( TSharedRef<FLayoutNode> InNode )
                {
                    ChildNodes.Add(InNode);
                    return SharedThis(this);
                }
                
                TSharedRef<FArea> SplitAt( int32 Index, TSharedRef<FLayoutNode> InNode )
                {
                    check(Index >= 0);
                    ChildNodes.Insert(InNode, FMath::Min(Index, ChildNodes.Num()));
                    return SharedThis(this);
                }
 
                TSharedRef<FArea> SetOrientation( const EOrientation InOrientation )
                {
                    Orientation = InOrientation;
                    return SharedThis(this);
                }
 
                TSharedRef<FArea> SetWindow( FVector2D InPosition, bool IsMaximized )
                {
                    WindowPlacement = Placement_Specified;
                    UnscaledWindowPosition = InPosition;
                    bIsMaximized = IsMaximized;
                    return SharedThis(this);
                }
 
                TSharedRef<FArea> SetExtensionId( FName InExtensionId )
                {
                    ExtensionId = InExtensionId;
                    return SharedThis(this);
                }
 
                FName GetExtensionId() const
                {
                    return ExtensionId;
                }
 
                virtual TSharedPtr<FArea> AsArea() override
                {
                    return SharedThis(this);
                }
 
                virtual ~FArea()
                {
                }
 
                UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
                TSharedRef<FArea> SetPanelDrawerActiveTab(FPanelDrawerTab&& InPanelDrawerTab)
                {
                    ActivePanelDrawerTab = InPanelDrawerTab;
                    return SharedThis(this);
                }
 
                UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
                TSharedRef<FArea> AddPanelDrawerInactiveTab(FPanelDrawerTab&& InPanelDrawerTab)
                {
                    InactivePanelDrawerTabs.Add(InPanelDrawerTab);
                    return SharedThis(this);
                }
 
                UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
                const TArray<FPanelDrawerTab>& GetPanelDrawerInactiveTabs() const
                {
                    return InactivePanelDrawerTabs;
                }
 
            bool DefinesPositionallySpecifiedFloatingWindow()const
            {
                return WindowPlacement == Placement_Specified;
            }
 
            protected:
                FArea( const float InWidth, const float InHeight )
                : WindowPlacement(Placement_Automatic)
                , UnscaledWindowPosition(FVector2D(0.0, 0.0))
                , UnscaledWindowSize(InWidth, InHeight)
                , bIsMaximized( false )
                {
                }
 
                EWindowPlacement WindowPlacement;
                FVector2D UnscaledWindowPosition;
                FVector2D UnscaledWindowSize;
                bool bIsMaximized;
                FName ExtensionId;
                FPanelDrawerTab ActivePanelDrawerTab;
                TArray<FPanelDrawerTab> InactivePanelDrawerTabs;
        };
 
 
        class FLayout : public TSharedFromThis<FLayout>
        {
                friend class FTabManager;
                
            public:
 
                static SLATE_API const TSharedRef<FTabManager::FLayout> NullLayout; 
                TSharedRef<FLayout> AddArea( const TSharedRef<FArea>& InArea )
                {
                    Areas.Add( InArea );
                    return SharedThis(this);
                }
 
                const TWeakPtr<FArea>& GetPrimaryArea() const
                {
                    return PrimaryArea;
                }
 
                TConstArrayView<TSharedRef<FArea>> GetAreas() const
                {
                    return Areas;
                }
                
            public:
                static SLATE_API TSharedPtr<FTabManager::FLayout> NewFromString( const FString& LayoutAsText );
                static SLATE_API TSharedPtr<FTabManager::FLayout> NewFromJson( const TSharedPtr<FJsonObject>& LayoutAsJson );
                SLATE_API FName GetLayoutName() const;
                SLATE_API TSharedRef<FJsonObject> ToJson() const;
                SLATE_API FString ToString() const;
 
                SLATE_API void ProcessExtensions(const FLayoutExtender& Extender);
 
            protected:
                static SLATE_API TSharedRef<class FJsonObject> PersistToString_Helper(const TSharedRef<FLayoutNode>& NodeToPersist);
                static SLATE_API TSharedRef<FLayoutNode> NewFromString_Helper( TSharedPtr<FJsonObject> JsonObject );
 
                FLayout(const FName& InLayoutName)
                    : LayoutName(InLayoutName)
                {}
 
                TWeakPtr< FArea > PrimaryArea;
                TArray< TSharedRef<FArea> > Areas;
                FName LayoutName;
        };  
 
 
        friend class FPrivateApi;
        class FPrivateApi
        {
            public:
                FPrivateApi( FTabManager& InTabManager )
                : TabManager( InTabManager )
                {
                }
 
                TSharedPtr<SWindow> GetParentWindow() const;
                void OnDockAreaCreated( const TSharedRef<SDockingArea>& NewlyCreatedDockArea );
                void OnTabRelocated( const TSharedRef<SDockTab>& RelocatedTab, const TSharedPtr<SWindow>& NewOwnerWindow );
                void OnTabOpening( const TSharedRef<SDockTab>& TabBeingOpened );
                void OnTabClosing( const TSharedRef<SDockTab>& TabBeingClosed );
                void OnDockAreaClosing( const TSharedRef<SDockingArea>& DockAreaThatIsClosing );
                void OnTabManagerClosing();
                bool CanTabLeaveTabWell(const TSharedRef<const SDockTab>& TabToTest) const;
                const TArray< TWeakPtr<SDockingArea> >& GetLiveDockAreas() const;
                void OnTabForegrounded( const TSharedPtr<SDockTab>& NewForegroundTab, const TSharedPtr<SDockTab>& BackgroundedTab );
 
                void ShowWindows();
                void HideWindows();
 
                void SetCanDoDeferredLayoutSave(bool bInCanDoDeferredLayoutSave);
                TSharedPtr<SDockingArea> GetDockingAreaForPanelDrawer(const TSharedPtr<SWindow>& InWindow) const;
 
            private:
                FTabManager& TabManager;
                
        };
 
        SLATE_API FTabManager::FPrivateApi& GetPrivateApi();
 
    public:
        class FSearchPreference
        {
        public:
            virtual TSharedPtr<SDockTab> Search(const FTabManager& Manager, FName PlaceholderId, const TSharedRef<SDockTab>& UnmanagedTab) const = 0;
            virtual ~FSearchPreference() {}
        };
 
        class FRequireClosedTab : public FSearchPreference
        {
        public:
            SLATE_API virtual TSharedPtr<SDockTab> Search(const FTabManager& Manager, FName PlaceholderId, const TSharedRef<SDockTab>& UnmanagedTab) const override;
        };
 
        class FLiveTabSearch : public FSearchPreference
        {
        public:
            SLATE_API FLiveTabSearch(FName InSearchForTabId = NAME_None);
 
            SLATE_API virtual TSharedPtr<SDockTab> Search(const FTabManager& Manager, FName PlaceholderId, const TSharedRef<SDockTab>& UnmanagedTab) const override;
 
        private:
            FName SearchForTabId;
        };
 
        class FLastMajorOrNomadTab : public FSearchPreference
        {
        public:
            SLATE_API FLastMajorOrNomadTab(FName InFallbackTabId);
 
            SLATE_API virtual TSharedPtr<SDockTab> Search(const FTabManager& Manager, FName PlaceholderId, const TSharedRef<SDockTab>& UnmanagedTab) const override;
        private:
            FName FallbackTabId;
        };
 
    public:
        static TSharedRef<FLayout> NewLayout( const FName LayoutName )
        {
            return MakeShareable( new FLayout(LayoutName) );
        }
        
        static TSharedRef<FArea> NewPrimaryArea()
        {
            TSharedRef<FArea>Area = MakeShareable( new FArea(0,0) );
            Area->WindowPlacement = FArea::Placement_NoWindow;
            return Area;
        }
 
        static TSharedRef<FArea> NewArea( const float Width, const float Height )
        {
            return MakeShareable( new FArea( Width, Height ) );
        }
 
        static TSharedRef<FArea> NewArea( const FVector2D& WindowSize )
        {
            return MakeShareable( new FArea( UE_REAL_TO_FLOAT(WindowSize.X), UE_REAL_TO_FLOAT(WindowSize.Y) ) );
        }
        
        static TSharedRef<FStack> NewStack() 
        {
            return MakeShareable( new FStack() );
        }
        
        static TSharedRef<FSplitter> NewSplitter()
        {
            return MakeShareable( new FSplitter() );
        }
 
        static void RegisterDefaultTabWindowSize(const FTabId& TabName, const FVector2D DefaultSize)
        {
            DefaultTabWindowSizeMap.Add(TabName, DefaultSize);
        }
 
        static void UnregisterDefaultTabWindowSize(const FTabId& TabName)
        {
            DefaultTabWindowSizeMap.Remove(TabName);
        }
 
        SLATE_API void SetOnPersistLayout( const FOnPersistLayout& InHandler );
 
        SLATE_API void CloseAllAreas();
 
        SLATE_API TSharedRef<FTabManager::FLayout> PersistLayout() const;
 
        SLATE_API void SavePersistentLayout();
 
        SLATE_API void RequestSavePersistentLayout();
 
        SLATE_API void ClearPendingLayoutSave();
 
        SLATE_API FTabSpawnerEntry& RegisterTabSpawner(const FName TabId, const FOnSpawnTab& OnSpawnTab, const FCanSpawnTab& CanSpawnTab = FCanSpawnTab());
 
        SLATE_API bool UnregisterTabSpawner( const FName TabId );
 
        SLATE_API void UnregisterAllTabSpawners();
 
        SLATE_API TSharedPtr<SWidget> RestoreFrom(const TSharedRef<FLayout>& Layout, const TSharedPtr<SWindow>& ParentWindow, const bool bEmbedTitleAreaContent = false,
            const EOutputCanBeNullptr RestoreAreaOutputCanBeNullptr = EOutputCanBeNullptr::Never);
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API TSharedPtr<SWidget> RestorePanelDrawer(const TSharedRef<SWidget>& InContent, const TSharedRef<SWindow>& ParentWindow);
 
        SLATE_API void PopulateLocalTabSpawnerMenu( FMenuBuilder& PopulateMe );
 
        SLATE_API void PopulateTabSpawnerMenu(FMenuBuilder& PopulateMe, TSharedRef<FWorkspaceItem> MenuStructure);
 
        SLATE_API void PopulateTabSpawnerMenu( FMenuBuilder& PopulateMe, TSharedRef<FWorkspaceItem> MenuStructure, bool bIncludeOrphanedMenus);
 
        SLATE_API void PopulateTabSpawnerMenu( FMenuBuilder &PopulateMe, const FName& TabType );
 
        SLATE_API virtual void DrawAttention( const TSharedRef<SDockTab>& TabToHighlight );
 
        struct ESearchPreference
        {
            enum Type
            {
                PreferLiveTab,
                RequireClosedTab
            };
        };
 
        SLATE_API void InsertNewDocumentTab( FName PlaceholderId, FName NewTabId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab );
 
        SLATE_API void InsertNewDocumentTab( FName PlaceholderId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab );
        
        SLATE_API void InsertNewDocumentTab(FName PlaceholderId, ESearchPreference::Type SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab);
 
        SLATE_API void RestoreDocumentTab(FName PlaceholderId, ESearchPreference::Type SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab);
 
        SLATE_API virtual TSharedPtr<SDockTab> TryInvokeTab(const FTabId& TabId, bool bInvokeAsInactive = false);
 
        SLATE_API TSharedPtr<SDockTab> FindExistingLiveTab(const FTabId& TabId) const;
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API TSharedPtr<SDockTab> TryOpenTabInPanelDrawer(const FTabId& TabId, const TSharedPtr<SWindow>& ParentWindow, bool bForceInDrawerPanel = false);
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API TSharedPtr<SDockTab> TryToggleTabInPanelDrawer(const FTabId& TabId, const TSharedPtr<SWindow>& ParentWindow, bool bForceInDrawerPanel = false);
 
        SLATE_API virtual ~FTabManager();
 
        SLATE_API void SetAllowWindowMenuBar(bool bInAllowWindowMenuBar);
 
        bool AllowsWindowMenuBar() const { return bAllowPerWindowMenu; }
 
        SLATE_API void SetMenuMultiBox(const TSharedPtr<FMultiBox> NewMenuMutliBox, const TSharedPtr<SWidget> MenuWidget);
 
        SLATE_API void UpdateMainMenu(TSharedPtr<SDockTab> ForTab, const bool bForce);
 
        SLATE_API void SetMainTab(const TSharedRef<const SDockTab>& InTab);
 
        SLATE_API void SetMainTab(const FTabId& InMainTabID);
 
        SLATE_API bool IsReadOnly();
 
        SLATE_API void SetReadOnly(bool bInReadOnly);
    
        FOnReadOnlyModeChanged& GetOnReadOnlyModeChangedDelegate() { return OnReadOnlyModeChanged; }
 
        /* Prevent or allow all tabs to be drag */
        void SetCanDoDragOperation(bool CanDoDragOperation) { bCanDoDragOperation = CanDoDragOperation; }
        
        /* Return true if we can do drag operation */
        bool GetCanDoDragOperation() { return bCanDoDragOperation; }
 
        SLATE_API bool IsTabCloseable(const TSharedRef<const SDockTab>& InTab) const;
 
        SLATE_API bool IsTabAllowedInSidebar(const FTabId TabId) const;
 
        TOptional<ETabReadOnlyBehavior> GetTabReadOnlyBehavior(const FTabId& TabId) const;
 
        SLATE_API void ToggleSidebarOpenTabs();
 
        SLATE_API const TSharedRef<FWorkspaceItem> GetLocalWorkspaceMenuRoot() const;
 
        SLATE_API TSharedRef<FWorkspaceItem> AddLocalWorkspaceMenuCategory( const FText& CategoryTitle );
 
        SLATE_API void AddLocalWorkspaceMenuItem( const TSharedRef<FWorkspaceItem>& CategoryItem );
 
        SLATE_API void ClearLocalWorkspaceMenuCategories();
 
        SLATE_API bool HasTabSpawner(FName TabId) const;
 
        TSharedPtr<SDockTab> GetOwnerTab() { return OwnerTabPtr.Pin(); }
 
        SLATE_API TSharedRef<FNamePermissionList>& GetTabPermissionList();
 
        SLATE_API FUIAction GetUIActionForTabSpawnerMenuEntry(TSharedPtr<FTabSpawnerEntry> InTabMenuEntry);
 
        SLATE_API TArray< TWeakPtr<FTabSpawnerEntry> > CollectSpawners();
 
        SLATE_API TSharedPtr<FTabSpawnerEntry> FindTabSpawnerFor(FName TabId);
 
        SLATE_API const TSharedPtr<const FTabSpawnerEntry> FindTabSpawnerFor(FName TabId) const;
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API bool HasPanelDrawer(const TSharedPtr<SWindow>& ParentWindow) const;
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API bool IsPanelDrawerOpen(const TSharedPtr<SWindow>& ParentWindow) const;
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API void ClosePanelDrawer(const TSharedPtr<SWindow>& ParentWindow);
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        DECLARE_MULTICAST_DELEGATE_OneParam(FOnPanelDrawerStateChanged, const FTabManager&);
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in development and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API FDelegateHandle RegisterOnPanelDrawerStateChanges(FOnPanelDrawerStateChanged::FDelegate&& InDelegate);
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
        UE_EXPERIMENTAL(5.7, "The panel drawer is still in devel1opment and might be removed. The api, implementation details and its form may change in near releases.")
        SLATE_API void UnregisterOnPanelDrawerStateChanges(FDelegateHandle InHandle);
 
    protected:
        SLATE_API void InvokeTabForMenu( FName TabId );
 
    protected:
        
        SLATE_API void InsertDocumentTab( FName PlaceholderId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab, bool bPlaySpawnAnim );
        SLATE_API void InsertDocumentTab( FName PlaceholderId, FName NewTabId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab, bool bPlaySpawnAnim );
 
        SLATE_API virtual void OpenUnmanagedTab(FName PlaceholderId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab);
            
        SLATE_API void PopulateTabSpawnerMenu_Helper( FMenuBuilder& PopulateMe, struct FPopulateTabSpawnerMenu_Args Args );
 
        SLATE_API void MakeSpawnerMenuEntry( FMenuBuilder &PopulateMe, const TSharedPtr<FTabSpawnerEntry> &InSpawnerNode );
 
        SLATE_API TSharedPtr<SDockTab> InvokeTab_Internal(const FTabId& TabId, bool bInvokeAsInactive = false, bool bForceOpenWindowIfNeeded = false);
 
        SLATE_API TSharedPtr<SDockTab> FindLastTabInWindow(TSharedPtr<SWindow> Window) const;
 
        SLATE_API TSharedPtr<SDockingTabStack> FindPotentiallyClosedTab( const FTabId& ClosedTabId );
 
        typedef TMap< FName, TSharedRef<FTabSpawnerEntry> > FTabSpawner;
        
        static TSharedRef<FTabManager> New( const TSharedPtr<SDockTab>& InOwnerTab, const TSharedRef<FTabSpawner>& InNomadTabSpawner )
        {
            return MakeShareable( new FTabManager(InOwnerTab, InNomadTabSpawner) );
        }
 
        SLATE_API FTabManager( const TSharedPtr<SDockTab>& InOwnerTab, const TSharedRef<FTabManager::FTabSpawner> & InNomadTabSpawner );
 
    SLATE_API TSharedPtr<SDockingArea> RestoreArea(
        const TSharedRef<FArea>& AreaToRestore, const TSharedPtr<SWindow>& InParentWindow, const bool bEmbedTitleAreaContent = false,
        const EOutputCanBeNullptr OutputCanBeNullptr = EOutputCanBeNullptr::Never, bool bForceOpenWindowIfNeeded = false);
 
    SLATE_API TSharedPtr<class SDockingNode> RestoreArea_Helper(const TSharedRef<FLayoutNode>& LayoutNode, const TSharedPtr<SWindow>& ParentWindow, const bool bEmbedTitleAreaContent,
        FSidebarTabLists& OutSidebarTabs, const EOutputCanBeNullptr OutputCanBeNullptr = EOutputCanBeNullptr::Never, bool bForceOpenWindowIfNeeded = false);
 
        SLATE_API bool CanRestoreSplitterContent(TArray<TSharedRef<class SDockingNode>>& DockingNodes, const TSharedRef<FSplitter>& SplitterNode, const TSharedPtr<SWindow>& ParentWindow, FSidebarTabLists& OutSidebarTabs, const EOutputCanBeNullptr OutputCanBeNullptr);
        SLATE_API void RestoreSplitterContent(const TArray<TSharedRef<class SDockingNode>>& DockingNodes, const TSharedRef<class SDockingSplitter>& SplitterWidget);
 
        SLATE_API void RestoreSplitterContent(const TSharedRef<FSplitter>& SplitterNode, const TSharedRef<class SDockingSplitter>& SplitterWidget, const TSharedPtr<SWindow>& ParentWindow, FSidebarTabLists& OutSidebarTabs);
 
        SLATE_API bool IsValidTabForSpawning( const FTab& SomeTab ) const;
        SLATE_API bool IsAllowedTab(const FTabId& TabId) const;
        SLATE_API bool IsAllowedTabType(const FName TabType) const;
 
        SLATE_API TSharedPtr<SDockTab> SpawnTab(const FTabId& TabId, const TSharedPtr<SWindow>& ParentWindow, const bool bCanOutputBeNullptr = false);
 
        SLATE_API TSharedPtr<class SDockingTabStack> FindTabInLiveAreas( const FTabMatcher& TabMatcher ) const;
        static SLATE_API TSharedPtr<class SDockingTabStack> FindTabInLiveArea( const FTabMatcher& TabMatcher, const TSharedRef<SDockingArea>& InArea );
 
        static bool HasAnyMatchingTabs( const TSharedRef<FTabManager::FLayoutNode>& SomeNode, const TFunctionRef<bool(const FTab&)>& Matcher );
 
    public:
        SLATE_API bool HasValidOpenTabs( const TSharedRef<FTabManager::FLayoutNode>& SomeNode ) const;
 
        SLATE_API TSharedPtr<FArea> GetAreaFromInitialLayoutWithTabType(const FTabId& InTabIdToMatch ) const;
 
protected:
        SLATE_API bool HasValidTabs( const TSharedRef<FTabManager::FLayoutNode>& SomeNode ) const;
 
        SLATE_API void SetTabsTo(const TSharedRef<FTabManager::FLayoutNode>& SomeNode, const ETabState::Type NewTabState, const ETabState::Type OriginalTabState) const;
 
        SLATE_API virtual void OnTabForegrounded( const TSharedPtr<SDockTab>& NewForegroundTab, const TSharedPtr<SDockTab>& BackgroundedTab );
        SLATE_API virtual void OnTabRelocated( const TSharedRef<SDockTab>& RelocatedTab, const TSharedPtr<SWindow>& NewOwnerWindow );
        SLATE_API virtual void OnTabOpening( const TSharedRef<SDockTab>& TabBeingOpened );
        SLATE_API virtual void OnTabClosing( const TSharedRef<SDockTab>& TabBeingClosed );
        SLATE_API virtual void OnTabManagerClosing();
        SLATE_API virtual bool CanCloseManager( const TSet< TSharedRef<SDockTab> >& TabsToIgnore = TSet< TSharedRef<SDockTab> >() );
 
        static SLATE_API void GetAllStacks( const TSharedRef<SDockingArea>& InDockArea, TArray< TSharedRef<SDockingTabStack> >& OutTabStacks );
 
        static SLATE_API TSharedPtr<FTabManager::FStack> FindTabUnderNode( const FTabMatcher& Matcher, const TSharedRef<FTabManager::FLayoutNode>& NodeToSearchUnder );
        SLATE_API int32 FindTabInCollapsedAreas( const FTabMatcher& Matcher );
        SLATE_API void RemoveTabFromCollapsedAreas( const FTabMatcher& Matcher );
 
        SLATE_API virtual void UpdateStats();
        
        virtual void FinishRestore() {};
 
 
        /*
         * Search the docking area to see if we have one that is part of the window.
         */
        TSharedPtr<SDockingArea> GetDockingAreaForWindow(const TSharedRef<SWindow>& InWindow) const;
 
        /*
         * Search the docking area to see if we have one that is part of the window. With some customized Logic for the panel drawer.
         */
        TSharedPtr<SDockingArea> GetDockingAreaForPanelDrawer(const TSharedPtr<SWindow>& InWindow) const;
 
    private:
        SLATE_API void GetRecordableStats( int32& OutTabCount, TArray<TSharedPtr<SWindow>>& OutUniqueParentWindows ) const;
 
    void FixLayoutLoadingPrimaryArea(const TSharedRef<FArea>& InPrimaryArea);
 
    TSharedPtr<SDockingTabStack> AttemptToOpenTab( const FTabId& ClosedTabId, bool bForceOpenWindowIfNeeded = false );
 
    bool HasAnyTabWithTabId( const TSharedRef<FTabManager::FLayoutNode>& SomeNode, const FName& InTabTypeToMatch ) const;
 
    TSharedRef<FArea> GetAreaForTabId(const FTabId& TabId);
 
    FText GetTabLabelBasedOnSpawner(const TSharedPtr<FTabSpawnerEntry>& InSpawnerEntry) const;
 
    bool InvokeTab_CanInvokeTab(const FTabId& TabId) const;
    TSharedPtr<SDockTab> InvokeTab_FindOrReuseExistingTab(const FTabId& TabId) const;
    void InvokeTab_DrawAttentionToTab(const TSharedPtr<SDockTab>& InvokedTab);
 
    TSharedPtr<SDockTab> InvokeTabInPanelDrawer(const FTabId& TabId, bool bToggleIfActiveInDrawer, const TSharedPtr<SWindow>& ParentWindow, bool bForceInDrawerPanel);
 
    bool CanInvokeInPanelDrawer(const FTabId& TabId, const TSharedPtr<SDockingArea>& DockingArea, TSharedPtr<SDockTab>& OutTab, bool bForceInDrawerPanel);
 
    void SetTabInPanelDrawer(const TSharedPtr<SDockTab>& InTab, const TSharedPtr<SDockingArea>& TargetDockingArea, const TSharedPtr<SWindow>& InWindow);
 
    void OnPanelDrawerStateChanged() const;
 
    bool RemoveFromHiddenPanelDrawerTabs(TSharedPtr<SDockTab> ExistingTab);
 
    void HandleClosingAreaPanelDrawerData(const TSharedPtr<SDockingArea>& ClosingDockingArea);
 
    protected:
        FTabSpawner TabSpawner;
        TSharedRef<FTabSpawner> NomadTabSpawner;
 
        SLATE_API bool HasTabSpawnerFor(FName TabId) const;
 
        TArray< TWeakPtr<SDockingArea> > DockAreas;
        TArray< TSharedRef<FTabManager::FArea> > CollapsedDockAreas;
        TArray< TSharedRef<FTabManager::FArea> > InvalidDockAreas;
 
        TSharedPtr<FWorkspaceItem> LocalWorkspaceMenuRoot;
 
        TWeakPtr<SDockTab> OwnerTabPtr;
 
        TSharedPtr<FMultiBox> MenuMultiBox;
        TSharedPtr<SWidget> MenuWidget;
 
        TSharedRef<FPrivateApi> PrivateApi;
 
        FName ActiveLayoutName;
 
        FOnPersistLayout OnPersistLayout_Handler;
 
        int32 LastDocumentUID;
 
        SLATE_API const static FVector2D FallbackWindowSize;
 
        static SLATE_API TMap<FTabId, FVector2D> DefaultTabWindowSizeMap;
 
        static SLATE_API FVector2D GetDefaultTabWindowSize(const FTabId& TabId);
 
        FTabId MainNonCloseableTabID;
 
        TSharedPtr<const SDockTab> PendingMainNonClosableTab;
 
        bool bEnforceMainTab = false;
 
        TWeakPtr<SWindow> LastMajorDockWindow;
 
        /* Prevent or allow Drag operation. */
        bool bCanDoDragOperation = true;
 
        bool bCanDoDeferredLayoutSave = true;
 
        bool bAllowPerWindowMenu = false;
 
        FTSTicker::FDelegateHandle PendingLayoutSaveHandle;
 
        TSharedRef<FNamePermissionList> TabPermissionList;
 
        TArray<TWeakPtr<SDockTab>> TemporarilySidebaredTabs;
 
        bool bReadOnly = false;
 
        FOnReadOnlyModeChanged OnReadOnlyModeChanged;
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
        FOnPanelDrawerStateChanged OnPanelDrawerStateChangedDelegate;
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
        TMap<FTabId, TSharedRef<SDockTab>> PanelDrawerActiveHiddenTabs;
};
 
 
 
class FProxyTabmanager;
 
 
class FGlobalTabmanager : public FTabManager
{
public: 
 
    static SLATE_API const TSharedRef<FGlobalTabmanager>& Get();
 
    SLATE_API FDelegateHandle OnActiveTabChanged_Subscribe( const FOnActiveTabChanged::FDelegate& InDelegate );
 
    SLATE_API void OnActiveTabChanged_Unsubscribe( FDelegateHandle Handle );
 
    SLATE_API FDelegateHandle OnTabForegrounded_Subscribe(const FOnActiveTabChanged::FDelegate& InDelegate);
 
    SLATE_API void OnTabForegrounded_Unsubscribe(FDelegateHandle Handle);
 
    SLATE_API TSharedPtr<SDockTab> GetActiveTab() const;
 
    SLATE_API bool CanSetAsActiveTab(const TSharedPtr<SDockTab>& Tab);
 
    SLATE_API void SetActiveTab( const TSharedPtr<SDockTab>& NewActiveTab );
 
    SLATE_API FTabSpawnerEntry& RegisterNomadTabSpawner( const FName TabId, const FOnSpawnTab& OnSpawnTab, const FCanSpawnTab& CanSpawnTab = FCanSpawnTab());
 
    SLATE_API void UnregisterNomadTabSpawner( const FName TabId );
 
    SLATE_API void SetApplicationTitle( const FText& AppTitle );
 
    SLATE_API const FText& GetApplicationTitle() const;
 
    static TSharedRef<FGlobalTabmanager> New()
    {
        return MakeShareable( new FGlobalTabmanager() );
    }
 
    SLATE_API virtual bool CanCloseManager( const TSet< TSharedRef<SDockTab> >& TabsToIgnore = TSet< TSharedRef<SDockTab> >()) override;
 
    SLATE_API TSharedPtr<SDockTab> GetMajorTabForTabManager(const TSharedRef<FTabManager>& ChildManager);
 
    SLATE_API TSharedPtr<FTabManager> GetTabManagerForMajorTab(const TSharedPtr<SDockTab> DockTab) const;
 
    SLATE_API TSharedPtr<FTabManager> GetSubTabManagerForWindow(const TSharedRef<SWindow>& InWindow) const;
 
    SLATE_API void DrawAttentionToTabManager( const TSharedRef<FTabManager>& ChildManager );
 
    SLATE_API TSharedRef<FTabManager> NewTabManager( const TSharedRef<SDockTab>& InOwnerTab );
    
    SLATE_API void UpdateMainMenu(const TSharedRef<SDockTab>& ForTab, bool const bForce);
 
    SLATE_API void SaveAllVisualState();
 
    SLATE_API void SetRootWindow( const TSharedRef<SWindow> InRootWindow );
 
    SLATE_API TSharedPtr<SWindow> GetRootWindow() const;
 
    SLATE_API void AddLegacyTabType(FName InLegacyTabType, FName InNewTabType);
 
    SLATE_API bool IsLegacyTabType(FName InTabType) const;
 
    SLATE_API FName GetTabTypeForPotentiallyLegacyTab(FName InTabType) const;
 
    int32 GetMaximumTabCount() const { return AllTabsMaxCount; }
 
    int32 GetMaximumWindowCount() const { return AllAreasWindowMaxCount; }
 
    SLATE_API void SetCanSavePersistentLayouts(bool bInCanSavePersistentLayouts);
 
    SLATE_API bool CanSavePersistentLayouts() const;
 
    SLATE_API void SetProxyTabManager(TSharedPtr<FProxyTabmanager> InProxyTabManager);
 
    SLATE_API bool GetShouldUseMiddleEllipsisForDockTabLabel() const;
 
    SLATE_API void SetShouldUseMiddleEllipsisForDockTabLabel(const bool bInShouldUseMiddleEllipsis);
 
    DECLARE_DELEGATE(FOnOverrideDockableAreaRestore);
    FOnOverrideDockableAreaRestore OnOverrideDockableAreaRestore_Handler;
 
protected:
    SLATE_API virtual void OnTabForegrounded( const TSharedPtr<SDockTab>& NewForegroundTab, const TSharedPtr<SDockTab>& BackgroundedTab ) override;
    SLATE_API virtual void OnTabRelocated( const TSharedRef<SDockTab>& RelocatedTab, const TSharedPtr<SWindow>& NewOwnerWindow ) override;
    SLATE_API virtual void OnTabClosing( const TSharedRef<SDockTab>& TabBeingClosed ) override;
    SLATE_API virtual void UpdateStats() override;
 
    SLATE_API virtual void OpenUnmanagedTab(FName PlaceholderId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab) override;
 
    SLATE_API virtual void FinishRestore() override;
 
public:
    SLATE_API virtual void OnTabManagerClosing() override;
 
    SLATE_API void SetInitialLayoutSP(TSharedPtr<FTabManager::FLayout> InLayout);
 
    SLATE_API TSharedPtr<FTabManager::FLayout> GetInitialLayoutSP();
    
private:
 
    using FTabAndManagerForDrawer = TPair<TSharedPtr<SDockTab>, TSharedPtr<FTabManager>>;
    void RelocatePanelDrawerNomadTab(FTabAndManagerForDrawer ForegroundTabAndSubManager, FTabAndManagerForDrawer BackgroundedTabAndSubManager);
 
    bool bShouldUseMiddleEllipsisForDockTabLabel = false;
 
    struct FSubTabManager
    {
        FSubTabManager( const TSharedRef<SDockTab>& InMajorTab, const TSharedRef<FTabManager>& InTabManager )
        : MajorTab( InMajorTab )
        , TabManager( InTabManager )
        {
        }
 
        TWeakPtr<SDockTab> MajorTab;
        TWeakPtr<FTabManager> TabManager;
    };
 
    struct FindByTab
    {
        FindByTab(const TSharedRef<SDockTab>& InTabToFind)
            : TabToFind(InTabToFind)
        {
        }
 
        bool operator()(const FGlobalTabmanager::FSubTabManager& TabManagerPair) const
        {
            return TabManagerPair.TabManager.IsValid() && TabManagerPair.MajorTab.IsValid() && TabManagerPair.MajorTab.Pin() == TabToFind;
        }
 
        const TSharedRef<SDockTab>& TabToFind;
    };
 
    struct FindByManager
    {
        FindByManager(const TSharedRef<FTabManager>& InManagerToFind)
            : ManagerToFind(InManagerToFind)
        {
        }
 
        bool operator()(const FGlobalTabmanager::FSubTabManager& TabManagerPair) const
        {
            return TabManagerPair.TabManager.IsValid() && TabManagerPair.MajorTab.IsValid() && TabManagerPair.TabManager.Pin() == ManagerToFind;
        }
 
        const TSharedRef<FTabManager>& ManagerToFind;
    };
 
    FGlobalTabmanager()
    : FTabManager( TSharedPtr<SDockTab>(), MakeShareable( new FTabSpawner() ) )
        , AllTabsMaxCount(0)
        , AllAreasWindowMaxCount(0)
        , bCanSavePersistentLayouts(true)
    {
    }
 
    TArray< FSubTabManager > SubTabManagers;
 
    TWeakPtr<SDockTab> ActiveTabPtr;
 
    FOnActiveTabChanged OnActiveTabChanged;
 
    FOnActiveTabChanged TabForegrounded;
 
    FText AppTitle;
 
    TWeakPtr<SWindow> RootWindowPtr;
 
    TMap<FName, FName> LegacyTabTypeRedirectionMap;
 
    int32 AllTabsMaxCount;
 
    int32 AllAreasWindowMaxCount;
 
    bool bCanSavePersistentLayouts;
 
    TSharedPtr<FProxyTabmanager> ProxyTabManager;
 
    TSharedPtr<FTabManager::FLayout> InitialLayoutSP;
};
 
//#HACK VREDITOR - Had to introduce the proxy tab manager to steal asset tabs.
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FIsTabSupportedEvent, FTabId /* TabId */, bool& /* bOutIsSupported */ );
DECLARE_MULTICAST_DELEGATE_OneParam(FOnTabEvent, TSharedPtr<SDockTab>);
 
 
class FProxyTabmanager : public FTabManager
{
public:
 
    FProxyTabmanager(TSharedRef<SWindow> InParentWindow)
        : FTabManager(TSharedPtr<SDockTab>(), MakeShareable(new FTabSpawner()))
        , ParentWindow(InParentWindow)
    {
        bCanDoDragOperation = false;
    }
 
    SLATE_API virtual void OpenUnmanagedTab(FName PlaceholderId, const FSearchPreference& SearchPreference, const TSharedRef<SDockTab>& UnmanagedTab) override;
    SLATE_API virtual void DrawAttention(const TSharedRef<SDockTab>& TabToHighlight) override;
    
    SLATE_API bool IsTabSupported( const FTabId TabId ) const;
    SLATE_API void SetParentWindow(TSharedRef<SWindow> InParentWindow);
 
public:
    FIsTabSupportedEvent OnIsTabSupported;
    FOnTabEvent OnTabOpened;
    FOnTabEvent OnAttentionDrawnToTab;
 
private:
    TWeakPtr<SWindow> ParentWindow;
};