SDockingArea.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Layout/Visibility.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Input/Reply.h"
#include "Widgets/SOverlay.h"
#include "Widgets/SWindow.h"
#include "Framework/Docking/TabManager.h"
#include "Framework/Docking/SDockingNode.h"
#include "Framework/Docking/SDockingSplitter.h"
#include "Framework/Docking/SPanelDrawerArea.h"
 
class STabSidebar;
 
struct FSidebarTabLists
{
    TArray<TSharedRef<SDockTab>> LeftSidebarTabs;
    TArray<TSharedRef<SDockTab>> RightSidebarTabs;
};
 
class SDockingArea : public SDockingSplitter
{
public:
 
    SLATE_BEGIN_ARGS(SDockingArea)
        : _ParentWindow()
        , _ShouldManageParentWindow(true)
        , _InitialContent()
        {
            // Visible by default, but don't absorb clicks
            _Visibility = EVisibility::SelfHitTestInvisible;
        }
        
        /* The window whose content area this dock area is directly embedded within.  By default, ShouldManageParentWindow is
           set to true, which means the dock area will also destroy the window when the last tab goes away.  Assigning a
           parent window also allows the docking area to embed title area widgets (minimize, maximize, etc) into its content area */
        SLATE_ARGUMENT( TSharedPtr<SWindow>, ParentWindow )
 
        
        SLATE_ARGUMENT( bool, ShouldManageParentWindow )
 
         
        SLATE_ARGUMENT( TSharedPtr<SDockingNode>, InitialContent )
 
    SLATE_END_ARGS()
 
    SLATE_API void Construct( const FArguments& InArgs, const TSharedRef<FTabManager>& InTabManager, const TSharedRef<FTabManager::FArea>& PersistentNode );
 
    virtual Type GetNodeType() const override
    {
        return SDockingNode::DockArea;
    }
    
    SLATE_API virtual TSharedPtr<SDockingArea> GetDockArea() override;
    SLATE_API virtual TSharedPtr<const SDockingArea> GetDockArea() const override;
 
    SLATE_API TSharedPtr<SWindow> GetParentWindow() const;
 
    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 OnUserAttemptingDock( SDockingNode::RelativeDirection Direction, const FDragDropEvent& DragDropEvent ) override;
 
    SLATE_API void OnTabFoundNewHome( const TSharedRef<SDockTab>& RelocatedTab, const TSharedRef<SWindow>& NewOwnerWindow );
 
    // Show the dock-from-outside dock targets
    SLATE_API void ShowCross();
 
    // Hide the dock-from-outside dock targets
    SLATE_API void HideCross();
 
    SLATE_API void CleanUp( ELayoutModification RemovalMethod );
 
    SLATE_API void SetParentWindow( const TSharedRef<SWindow>& NewParentWindow );
 
    SLATE_API virtual TSharedPtr<FTabManager::FLayoutNode> GatherPersistentLayout() const override;
 
    SLATE_API TSharedRef<FTabManager> GetTabManager() const;
 
    SLATE_API ESidebarLocation AddTabToSidebar(TSharedRef<SDockTab> TabToAdd);
 
    SLATE_API bool RestoreTabFromSidebar(TSharedRef<SDockTab> TabToRemove);
 
    SLATE_API bool IsTabInSidebar(TSharedRef<SDockTab> Tab) const;
 
    SLATE_API bool RemoveTabFromSidebar(TSharedRef<SDockTab> Tab);
 
    SLATE_API bool TryOpenSidebarDrawer(TSharedRef<SDockTab> TabToOpen) const;
 
    SLATE_API void AddSidebarTabsFromRestoredLayout(const FSidebarTabLists& SidebarTabs);
 
    SLATE_API TArray<TSharedRef<SDockTab>> GetAllSidebarTabs() const;
 
    bool CanHaveSidebar() const { return bCanHaveSidebar; }
 
    bool HostTabIntoPanelDrawer(const TSharedRef<SDockTab>& InTab);
 
    void ClosePanelDrawer();
 
    TSharedPtr<SDockTab> ClosePanelDrawerForTransfer();
 
    bool IsPanelDrawerOpen() const;
 
    bool HasPanelDrawer() const;
 
    TSharedPtr<SDockTab> GetPanelDrawerSystemHostedTab(const FTabId& TabId) const;
 
    TSharedPtr<SDockTab> GetPanelDrawerHostedTab() const;
 
    void SetPanelDrawerArea(const TSharedPtr<UE::Slate::Private::SPanelDrawerArea>& InPanelDrawerArea);
 
    void DetachPanelDrawerArea();
 
    bool RestorePanelDrawerArea();
 
    TMap<FTabId, TSharedRef<SDockTab>> GetPanelDrawerKeepAliveTabs() const;
 
    TSharedPtr<UE::Slate::Private::SPanelDrawerArea> GetPanelDrawerArea() const;
 
    bool RemoveHiddenInactivePanelDrawerTab(const TSharedPtr<SDockTab>& TabToRemove);
 
    void CleanPanelDrawer();
 
    void SetPanelDrawerHiddenActiveTab(TSharedRef<UE::Slate::Private::FPanelDrawerData>&& InPanelDrawerData);
 
protected:
    SLATE_API virtual SDockingNode::ECleanupRetVal CleanUpNodes() override;
 
private:
 
    TSharedPtr<SDockingArea> GetTopLevelDockingArea() const;
 
    SLATE_API EVisibility TargetCrossVisibility() const;
    SLATE_API EVisibility TargetCrossCenterVisibility() const;
    SLATE_API void DockFromOutside(SDockingNode::RelativeDirection Direction, const FDragDropEvent& DragDropEvent);
 
    SLATE_API void OnOwningWindowBeingDestroyed(const TSharedRef<SWindow>& WindowBeingDestroyed);
 
    SLATE_API void OnOwningWindowActivated();
    
    SLATE_API virtual void OnLiveTabAdded() override;
 
    SLATE_API void UpdateWindowChromeAndSidebar();
 
    bool RestorePanelDrawerArea(const TSharedPtr<UE::Slate::Private::SPanelDrawerArea>& InPanelDrawerAreaOverride);
private:    
    TSharedPtr<STabSidebar> LeftSidebar;
    TSharedPtr<STabSidebar> RightSidebar;
 
    TWeakPtr<SWindow> ParentWindowPtr;
 
    SOverlay::FOverlaySlot* WindowControlsArea;
 
    bool bManageParentWindow;
 
    TWeakPtr<FTabManager> MyTabManager;
 
    bool bIsOverlayVisible;
 
    bool bIsCenterTargetVisible;
 
    bool bCleanUpUponTabRelocation;
 
    bool bCanHaveSidebar;
 
    TWeakPtr<UE::Slate::Private::SPanelDrawerArea> PanelDrawerPtr;
 
    TSharedPtr<UE::Slate::Private::FPanelDrawerData> HiddenPanelDrawerTabToReopenOnRestore;
    TMap<FTabId, TSharedPtr<UE::Slate::Private::FPanelDrawerData>> InactivePanelDrawerTabs;
};