895 lines
23 KiB
C++
895 lines
23 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "Toolkits/BaseToolkit.h"
|
|
#include "Tools/EdModeInteractiveToolsContext.h"
|
|
#include "Toolkits/ToolkitManager.h"
|
|
#include "PropertyEditorModule.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "IDetailsView.h"
|
|
#include "InteractiveToolManager.h"
|
|
#include "Editor.h"
|
|
#include "InteractiveTool.h"
|
|
#include "Tools/UEdMode.h"
|
|
#include "Framework/MultiBox/MultiBoxBuilder.h"
|
|
#include "EdMode.h"
|
|
#include "EditorModeManager.h"
|
|
#include "Widgets/Layout/SScrollBox.h"
|
|
#include "Widgets/Layout/SExpandableArea.h"
|
|
#include "Toolkits/AssetEditorModeUILayer.h"
|
|
#include "Widgets/Docking/SDockTab.h"
|
|
#include "Widgets/Input/SCheckBox.h"
|
|
#include "Widgets/Images/SImage.h"
|
|
#include "Widgets/Input/SSegmentedControl.h"
|
|
#include "Styling/AppStyle.h"
|
|
#include "Styling/StyleColors.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "BaseToolkit"
|
|
|
|
FBaseToolkit::FBaseToolkit()
|
|
: ToolkitMode( EToolkitMode::Standalone ),
|
|
ToolkitCommands( new FUICommandList() )
|
|
{
|
|
WorkspaceMenuCategory = FWorkspaceItem::NewGroup(LOCTEXT("WorkspaceMenu_BaseToolkit", "Toolkit"));
|
|
}
|
|
|
|
|
|
FBaseToolkit::~FBaseToolkit()
|
|
{
|
|
}
|
|
|
|
|
|
|
|
bool FBaseToolkit::IsWorldCentricAssetEditor() const
|
|
{
|
|
return ToolkitMode == EToolkitMode::WorldCentric;
|
|
}
|
|
|
|
|
|
|
|
bool FBaseToolkit::IsHosted() const
|
|
{
|
|
return ToolkitHost.IsValid();
|
|
}
|
|
|
|
|
|
const TSharedRef< IToolkitHost > FBaseToolkit::GetToolkitHost() const
|
|
{
|
|
return ToolkitHost.Pin().ToSharedRef();
|
|
}
|
|
|
|
FName FBaseToolkit::GetToolkitContextFName() const
|
|
{
|
|
return GetToolkitFName();
|
|
}
|
|
|
|
|
|
bool FBaseToolkit::ProcessCommandBindings( const FKeyEvent& InKeyEvent ) const
|
|
{
|
|
if( ToolkitCommands->ProcessCommandBindings( InKeyEvent ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
FString FBaseToolkit::GetTabPrefix() const
|
|
{
|
|
if( IsWorldCentricAssetEditor() )
|
|
{
|
|
return GetWorldCentricTabPrefix();
|
|
}
|
|
else
|
|
{
|
|
return TEXT( "" );
|
|
}
|
|
}
|
|
|
|
|
|
FLinearColor FBaseToolkit::GetTabColorScale() const
|
|
{
|
|
return IsWorldCentricAssetEditor() ? GetWorldCentricTabColorScale() : FLinearColor( 0, 0, 0, 0 );
|
|
}
|
|
|
|
void FBaseToolkit::CreateEditorModeManager()
|
|
{
|
|
}
|
|
|
|
void FBaseToolkit::BringToolkitToFront()
|
|
{
|
|
if( ensure( ToolkitHost.IsValid() ) )
|
|
{
|
|
// Bring the host window to front
|
|
ToolkitHost.Pin()->BringToFront();
|
|
// Tell the toolkit its been brought to the fore - give it a chance to update anything it needs to
|
|
ToolkitBroughtToFront();
|
|
}
|
|
}
|
|
|
|
TSharedPtr<class SWidget> FBaseToolkit::GetInlineContent() const
|
|
{
|
|
return TSharedPtr<class SWidget>();
|
|
}
|
|
|
|
|
|
bool FBaseToolkit::IsBlueprintEditor() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void FModeToolkit::Init(const TSharedPtr< class IToolkitHost >& InitToolkitHost)
|
|
{
|
|
Init(InitToolkitHost, TWeakObjectPtr<UEdMode>());
|
|
}
|
|
|
|
void FModeToolkit::Init(const TSharedPtr< class IToolkitHost >& InitToolkitHost, TWeakObjectPtr<UEdMode> InOwningMode)
|
|
{
|
|
check( InitToolkitHost.IsValid() );
|
|
|
|
ToolkitMode = EToolkitMode::Type::Standalone;
|
|
ToolkitHost = InitToolkitHost;
|
|
OwningEditorMode = InOwningMode;
|
|
PrimaryTabInfo = FMinorTabConfig();
|
|
ToolbarInfo = FMinorTabConfig();
|
|
|
|
if (OwningEditorMode.IsValid())
|
|
{
|
|
UInteractiveToolManager* EditorToolManager = OwningEditorMode->GetToolManager(EToolsContextScope::Editor);
|
|
if (EditorToolManager)
|
|
{
|
|
EditorToolManager->OnToolStarted.AddSP(this, &FModeToolkit::OnToolStarted);
|
|
EditorToolManager->OnToolEnded.AddSP(this, &FModeToolkit::OnToolEnded);
|
|
}
|
|
|
|
UInteractiveToolManager* ModeToolManager = OwningEditorMode->GetToolManager(EToolsContextScope::EdMode);
|
|
if (ModeToolManager)
|
|
{
|
|
ModeToolManager->OnToolStarted.AddSP(this, &FModeToolkit::OnToolStarted);
|
|
ModeToolManager->OnToolEnded.AddSP(this, &FModeToolkit::OnToolEnded);
|
|
}
|
|
}
|
|
|
|
|
|
FPropertyEditorModule& PropertyEditorModule = FModuleManager::GetModuleChecked<FPropertyEditorModule>("PropertyEditor");
|
|
|
|
{
|
|
FDetailsViewArgs ModeDetailsViewArgs;
|
|
ModeDetailsViewArgs.bAllowSearch = false;
|
|
ModeDetailsViewArgs.NameAreaSettings = FDetailsViewArgs::HideNameArea;
|
|
ModeDetailsViewArgs.bHideSelectionTip = true;
|
|
ModeDetailsViewArgs.DefaultsOnlyVisibility = EEditDefaultsOnlyNodeVisibility::Automatic;
|
|
ModeDetailsViewArgs.bShowOptions = false;
|
|
ModeDetailsViewArgs.bAllowMultipleTopLevelObjects = true;
|
|
|
|
CustomizeModeDetailsViewArgs(ModeDetailsViewArgs); // allow subclass to customize arguments
|
|
|
|
ModeDetailsView = PropertyEditorModule.CreateDetailView(ModeDetailsViewArgs);
|
|
}
|
|
|
|
{
|
|
FDetailsViewArgs DetailsViewArgs;
|
|
DetailsViewArgs.bAllowSearch = false;
|
|
DetailsViewArgs.NameAreaSettings = FDetailsViewArgs::HideNameArea;
|
|
DetailsViewArgs.bHideSelectionTip = true;
|
|
DetailsViewArgs.DefaultsOnlyVisibility = EEditDefaultsOnlyNodeVisibility::Automatic;
|
|
DetailsViewArgs.bShowOptions = false;
|
|
DetailsViewArgs.bAllowMultipleTopLevelObjects = true;
|
|
|
|
CustomizeDetailsViewArgs(DetailsViewArgs); // allow subclass to customize arguments
|
|
|
|
DetailsView = PropertyEditorModule.CreateDetailView(DetailsViewArgs);
|
|
}
|
|
|
|
GetEditorModeManager().OnEditorModeIDChanged().AddSP(this, &FModeToolkit::OnModeIDChanged);
|
|
|
|
if (HasToolkitBuilder())
|
|
{
|
|
ToolkitBuilder->VerticalToolbarElement->GenerateWidget();
|
|
}
|
|
}
|
|
|
|
|
|
FModeToolkit::~FModeToolkit()
|
|
{
|
|
if (IsHosted())
|
|
{
|
|
GetEditorModeManager().OnEditorModeIDChanged().RemoveAll(this);
|
|
if (OwningEditorMode.IsValid())
|
|
{
|
|
UInteractiveToolManager* EditorToolManager = OwningEditorMode->GetToolManager(EToolsContextScope::Editor);
|
|
if (EditorToolManager)
|
|
{
|
|
EditorToolManager->OnToolStarted.RemoveAll(this);
|
|
EditorToolManager->OnToolEnded.RemoveAll(this);
|
|
}
|
|
|
|
UInteractiveToolManager* ModeToolManager = OwningEditorMode->GetToolManager(EToolsContextScope::EdMode);
|
|
if (ModeToolManager)
|
|
{
|
|
ModeToolManager->OnToolStarted.RemoveAll(this);
|
|
ModeToolManager->OnToolEnded.RemoveAll(this);
|
|
}
|
|
}
|
|
}
|
|
if (ModeToolBarContainer)
|
|
{
|
|
ModeToolBarContainer->SetContent(SNullWidget::NullWidget);
|
|
}
|
|
if (ModeToolHeader)
|
|
{
|
|
ModeToolHeader->SetContent(SNullWidget::NullWidget);
|
|
}
|
|
if (InlineContentHolder)
|
|
{
|
|
InlineContentHolder->SetContent(SNullWidget::NullWidget);
|
|
}
|
|
OwningEditorMode.Reset();
|
|
}
|
|
|
|
void FModeToolkit::SetModeUILayer(const TSharedPtr<FAssetEditorModeUILayer> InLayer)
|
|
{
|
|
ModeUILayer = InLayer;
|
|
|
|
//TODO: Maybe Mode Toolbar Commands should be separate from the Toolkit Commands? Or the ModeUILayer should be
|
|
// responsible for a generic set of "Mode Commands"
|
|
ModeUILayer.Pin()->GetModeCommands()->Append(GetToolkitCommands());
|
|
ModeUILayer.Pin()->ToolkitHostReadyForUI().BindSP(this, &FModeToolkit::InvokeUI);
|
|
ModeUILayer.Pin()->ToolkitHostShutdownUI().BindSP(this, &FModeToolkit::ShutdownUI);
|
|
|
|
ModeUILayer.Pin()->RegisterSecondaryModeToolbarExtension().BindSP(this, &FModeToolkit::ExtendSecondaryModeToolbar);
|
|
}
|
|
|
|
void FModeToolkit::RegisterTabSpawners(const TSharedRef<FTabManager>& TabManager)
|
|
{
|
|
RequestModeUITabs();
|
|
}
|
|
|
|
void FModeToolkit::UnregisterTabSpawners(const TSharedRef<FTabManager>& TabManager)
|
|
{
|
|
}
|
|
|
|
FName FModeToolkit::GetToolkitFName() const
|
|
{
|
|
return FName("EditorModeToolkit");
|
|
}
|
|
|
|
FText FModeToolkit::GetBaseToolkitName() const
|
|
{
|
|
return NSLOCTEXT("EditorModeToolkit", "DisplayName", "EditorMode Tool");
|
|
}
|
|
|
|
FString FModeToolkit::GetWorldCentricTabPrefix() const
|
|
{
|
|
return FString();
|
|
}
|
|
|
|
bool FModeToolkit::IsAssetEditor() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const TArray< UObject* >* FModeToolkit::GetObjectsCurrentlyBeingEdited() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
FLinearColor FModeToolkit::GetWorldCentricTabColorScale() const
|
|
{
|
|
return FLinearColor();
|
|
}
|
|
|
|
void FModeToolkit::OnToolStarted(UInteractiveToolManager* Manager, UInteractiveTool* Tool)
|
|
{
|
|
// Update properties panel
|
|
if (!OwningEditorMode.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
UInteractiveTool* CurTool = OwningEditorMode->GetToolManager(EToolsContextScope::Editor)->GetActiveTool(EToolSide::Left);
|
|
if (CurTool == nullptr) // try Mode-level ToolManager
|
|
{
|
|
CurTool = OwningEditorMode->GetToolManager(EToolsContextScope::EdMode)->GetActiveTool(EToolSide::Left);
|
|
}
|
|
|
|
if (CurTool)
|
|
{
|
|
DetailsView->SetObjects(CurTool->GetToolProperties());
|
|
}
|
|
}
|
|
|
|
void FModeToolkit::OnToolEnded(UInteractiveToolManager* Manager, UInteractiveTool* Tool)
|
|
{
|
|
DetailsView->SetObject(nullptr);
|
|
}
|
|
|
|
class FEdMode* FModeToolkit::GetEditorMode() const
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
FText FModeToolkit::GetEditorModeDisplayName() const
|
|
{
|
|
if (const FEditorModeInfo* ModeInfo = GetEditorModeInfo())
|
|
{
|
|
return ModeInfo->Name;
|
|
}
|
|
|
|
return FText::GetEmpty();
|
|
}
|
|
|
|
FSlateIcon FModeToolkit::GetEditorModeIcon() const
|
|
{
|
|
if (const FEditorModeInfo* ModeInfo = GetEditorModeInfo())
|
|
{
|
|
return ModeInfo->IconBrush;
|
|
}
|
|
|
|
return FSlateIcon();
|
|
}
|
|
|
|
FEditorModeTools& FModeToolkit::GetEditorModeManager() const
|
|
{
|
|
check(IsHosted());
|
|
return GetToolkitHost()->GetEditorModeManager();
|
|
}
|
|
|
|
TWeakObjectPtr<UEdMode> FModeToolkit::GetScriptableEditorMode() const
|
|
{
|
|
return OwningEditorMode;
|
|
}
|
|
|
|
TSharedPtr<SWidget> FModeToolkit::GetInlineContent() const
|
|
{
|
|
return SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
[
|
|
ModeDetailsView.ToSharedRef()
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
[
|
|
DetailsView.ToSharedRef()
|
|
];
|
|
}
|
|
|
|
void FModeToolkit::BuildToolPalette(FName PaletteName, class FToolBarBuilder& ToolbarBuilder)
|
|
{
|
|
if (!OwningEditorMode.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
TMap<FName, TArray<TSharedPtr<FUICommandInfo>>> CommandLists = OwningEditorMode->GetModeCommands();
|
|
TArray<TSharedPtr<FUICommandInfo>>* CurrentCommandListPtr = CommandLists.Find(PaletteName);
|
|
if (CurrentCommandListPtr)
|
|
{
|
|
TArray<TSharedPtr<FUICommandInfo>> CurrentCommandList = *CurrentCommandListPtr;
|
|
for (TSharedPtr<FUICommandInfo> Command : CurrentCommandList)
|
|
{
|
|
ToolbarBuilder.AddToolBarButton(Command);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
FName FModeToolkit::GetCurrentPalette() const
|
|
{
|
|
return CurrentPaletteName;
|
|
}
|
|
|
|
void FModeToolkit::SetCurrentPalette(FName InPalette)
|
|
{
|
|
CurrentPaletteName = InPalette;
|
|
OnToolPaletteChanged(CurrentPaletteName);
|
|
OnPaletteChangedDelegate.Broadcast(InPalette);
|
|
}
|
|
|
|
void FModeToolkit::SetModeSettingsObject(UObject* InSettingsObject)
|
|
{
|
|
ModeDetailsView->SetObject(InSettingsObject);
|
|
}
|
|
|
|
void FModeToolkit::InvokeUI()
|
|
{
|
|
if (ModeUILayer.IsValid())
|
|
{
|
|
TSharedPtr<FAssetEditorModeUILayer> ModeUILayerPtr = ModeUILayer.Pin();
|
|
TSharedPtr<SDockTab> CreatedTab = ModeUILayerPtr->GetTabManager()->TryInvokeTab(UAssetEditorUISubsystem::TopLeftTabID);
|
|
UpdatePrimaryModePanel();
|
|
TSharedPtr<FUICommandList> CommandList;
|
|
if (!HasIntegratedToolPalettes())
|
|
{
|
|
if (GetScriptableEditorMode().IsValid())
|
|
{
|
|
UEdMode* ScriptableMode = GetScriptableEditorMode().Get();
|
|
CommandList = GetToolkitCommands();
|
|
|
|
// Also build the toolkit here
|
|
TArray<FName> PaletteNames;
|
|
GetToolPaletteNames(PaletteNames);
|
|
for (const FName& Palette : PaletteNames)
|
|
{
|
|
TSharedRef<SWidget> PaletteWidget = CreatePaletteWidget(CommandList, ScriptableMode->GetModeInfo().ToolbarCustomizationName, Palette);
|
|
ActiveToolBarRows.Emplace(ScriptableMode->GetID(), Palette, GetToolPaletteDisplayName(Palette), PaletteWidget);
|
|
}
|
|
}
|
|
if (!HasToolkitBuilder())
|
|
{
|
|
const TSharedPtr<SDockTab> CreatedToolbarTab = ModeUILayerPtr->GetTabManager()->TryInvokeTab(UAssetEditorUISubsystem::VerticalToolbarID);
|
|
ModeToolbarTab = CreatedToolbarTab;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void FModeToolkit::RebuildModeToolPalette()
|
|
{
|
|
if (ModeUILayer.IsValid() && HasIntegratedToolPalettes() == false)
|
|
{
|
|
if ( TSharedPtr<FAssetEditorModeUILayer> ModeUILayerPtr = ModeUILayer.Pin() )
|
|
{
|
|
TSharedPtr<FUICommandList> CommandList;
|
|
if (GetScriptableEditorMode().IsValid())
|
|
{
|
|
UEdMode* ScriptableMode = GetScriptableEditorMode().Get();
|
|
CommandList = GetToolkitCommands();
|
|
ActiveToolBarRows.Reset();
|
|
|
|
TArray<FName> PaletteNames;
|
|
GetToolPaletteNames(PaletteNames);
|
|
for (const FName& Palette : PaletteNames)
|
|
{
|
|
TSharedRef<SWidget> PaletteWidget = CreatePaletteWidget(CommandList, ScriptableMode->GetModeInfo().ToolbarCustomizationName, Palette);
|
|
ActiveToolBarRows.Emplace(ScriptableMode->GetID(), Palette, GetToolPaletteDisplayName(Palette), PaletteWidget);
|
|
}
|
|
|
|
RebuildModeToolBar();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool FModeToolkit::HasToolkitBuilder() const
|
|
{
|
|
return bUsesToolkitBuilder && ToolkitBuilder != nullptr;
|
|
}
|
|
|
|
TSharedRef<SDockTab> FModeToolkit::CreatePrimaryModePanel(const FSpawnTabArgs& Args)
|
|
{
|
|
TSharedPtr<SWidget> TabContent;
|
|
if (!HasToolkitBuilder())
|
|
{
|
|
TabContent = SNew(SBorder)
|
|
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
|
|
.Padding(0.0f)
|
|
[
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
.HAlign(HAlign_Left)
|
|
[
|
|
SAssignNew(ModeToolBarContainer, SBorder)
|
|
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
|
|
.Padding(FMargin(4, 0, 0, 0))
|
|
]
|
|
|
|
+ SVerticalBox::Slot()
|
|
.FillHeight(1.0f)
|
|
[
|
|
SNew(SVerticalBox)
|
|
|
|
+ SVerticalBox::Slot()
|
|
.Padding(0.0, 8.0, 0.0, 0.0)
|
|
.AutoHeight()
|
|
[
|
|
SAssignNew(ModeToolHeader, SBorder)
|
|
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
|
|
]
|
|
|
|
+ SVerticalBox::Slot()
|
|
.FillHeight(1)
|
|
[
|
|
SAssignNew(InlineContentHolder, SBorder)
|
|
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
|
|
.Visibility(this, &FModeToolkit::GetInlineContentHolderVisibility)
|
|
]
|
|
]
|
|
];
|
|
}
|
|
// else if ToolkitBuilder is defined, make the Toolkit
|
|
else
|
|
{
|
|
TabContent = SAssignNew(InlineContentHolder, SBorder)
|
|
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
|
|
.Padding(0.0f)
|
|
[
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
.HAlign(HAlign_Left)
|
|
[
|
|
SAssignNew(ModeToolBarContainer, SBorder)
|
|
.Padding(FMargin(4, 0, 0, 0))
|
|
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
|
|
]
|
|
];
|
|
}
|
|
|
|
const TSharedPtr<SDockTab> CreatedTab = SNew(SDockTab);
|
|
if (TabContent)
|
|
{
|
|
CreatedTab->SetContent(TabContent.ToSharedRef());
|
|
}
|
|
PrimaryTab = CreatedTab;
|
|
UpdatePrimaryModePanel();
|
|
return CreatedTab.ToSharedRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
void FModeToolkit::UpdatePrimaryModePanel()
|
|
{
|
|
if (GetEditorMode() || GetScriptableEditorMode().IsValid())
|
|
{
|
|
const FText TabName = GetEditorModeDisplayName();
|
|
const FSlateBrush* TabIcon = GetEditorModeIcon().GetSmallIcon();
|
|
if (PrimaryTab.IsValid())
|
|
{
|
|
TSharedPtr<SDockTab> TabPtr = PrimaryTab.Pin();
|
|
TabPtr->SetTabIcon(TabIcon);
|
|
TabPtr->SetLabel(TabName);
|
|
|
|
if (HasToolkitBuilder())
|
|
{
|
|
TabPtr->SetParentDockTabStackTabWellHidden(HasToolkitBuilder());
|
|
const TSharedPtr<SWidget> Content = GetInlineContent() ;
|
|
|
|
if ( Content && InlineContentHolder.IsValid() )
|
|
{
|
|
InlineContentHolder->SetContent( Content.ToSharedRef() );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (HasIntegratedToolPalettes())
|
|
{
|
|
TSharedRef<SSegmentedControl<FName>> PaletteTabBox = SNew(SSegmentedControl<FName>)
|
|
.UniformPadding(FMargin(8.f, 3.f))
|
|
.Value_Lambda([this]() { return GetCurrentPalette(); } )
|
|
.OnValueChanged_Lambda([this](const FName& Palette) { SetCurrentPalette(Palette); } );
|
|
|
|
// Only show if there is more than one child in the switcher
|
|
PaletteTabBox->SetVisibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateLambda([PaletteTabBox]() -> EVisibility
|
|
{
|
|
return PaletteTabBox->NumSlots() > 1 ? EVisibility::Visible : EVisibility::Collapsed;
|
|
})));
|
|
|
|
// Also build the toolkit here
|
|
TArray<FName> PaletteNames;
|
|
GetToolPaletteNames(PaletteNames);
|
|
|
|
TSharedPtr<FUICommandList> CommandList;
|
|
CommandList = GetToolkitCommands();
|
|
|
|
TSharedRef< SWidgetSwitcher > PaletteSwitcher = SNew(SWidgetSwitcher)
|
|
.WidgetIndex_Lambda(
|
|
[this, PaletteNames]() -> int32
|
|
{
|
|
int32 FoundIndex;
|
|
if (PaletteNames.Find(GetCurrentPalette(), FoundIndex))
|
|
{
|
|
return FoundIndex;
|
|
}
|
|
return 0;
|
|
});
|
|
|
|
|
|
for (auto Palette : PaletteNames)
|
|
{
|
|
FName ToolbarCustomizationName = GetEditorMode() ? GetEditorMode()->GetModeInfo().ToolbarCustomizationName : GetScriptableEditorMode()->GetModeInfo().ToolbarCustomizationName;
|
|
TSharedRef<SWidget> PaletteWidget = CreatePaletteWidget(CommandList, ToolbarCustomizationName, Palette);
|
|
|
|
const bool bRebuildChildren = false;
|
|
PaletteTabBox->AddSlot(Palette, false)
|
|
.Text(GetToolPaletteDisplayName(Palette));
|
|
|
|
PaletteSwitcher->AddSlot()
|
|
[
|
|
PaletteWidget
|
|
];
|
|
}
|
|
|
|
PaletteTabBox->RebuildChildren();
|
|
|
|
if (ModeToolHeader)
|
|
{
|
|
ModeToolHeader->SetContent(
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.Padding(0.f, 0.f, 0.f, 8.f)
|
|
.HAlign(HAlign_Center)
|
|
.AutoHeight()
|
|
[
|
|
PaletteTabBox
|
|
]
|
|
|
|
+ SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
[
|
|
PaletteSwitcher
|
|
]
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ModeToolHeader)
|
|
{
|
|
ModeToolHeader->SetContent(SNullWidget::NullWidget);
|
|
}
|
|
if (ModeToolBarContainer)
|
|
{
|
|
ModeToolBarContainer->SetContent(SNullWidget::NullWidget);
|
|
}
|
|
}
|
|
|
|
if (InlineContentHolder.IsValid())
|
|
{
|
|
if (TSharedPtr<SWidget> InlineContent = GetInlineContent())
|
|
{
|
|
InlineContentHolder->SetContent(
|
|
SNew(SScrollBox)
|
|
+ SScrollBox::Slot()
|
|
[
|
|
InlineContent.ToSharedRef()
|
|
]);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EVisibility FModeToolkit::GetInlineContentHolderVisibility() const
|
|
{
|
|
if (InlineContentHolder)
|
|
{
|
|
return InlineContentHolder->GetContent() == SNullWidget::NullWidget ? EVisibility::Collapsed : EVisibility::Visible;
|
|
}
|
|
return EVisibility::Collapsed;
|
|
}
|
|
|
|
EVisibility FModeToolkit::GetNoToolSelectedTextVisibility() const
|
|
{
|
|
if (InlineContentHolder)
|
|
{
|
|
return InlineContentHolder->GetContent() == SNullWidget::NullWidget ? EVisibility::Visible : EVisibility::Collapsed;
|
|
}
|
|
return EVisibility::Collapsed;
|
|
}
|
|
|
|
TSharedRef<SDockTab> FModeToolkit::MakeModeToolbarTab(const FSpawnTabArgs& Args)
|
|
{
|
|
TSharedRef<SDockTab> ToolbarTabRef =
|
|
SNew(SDockTab)
|
|
.Label(NSLOCTEXT("EditorModes", "EditorModesToolbarTitle", "Mode Toolbar"))
|
|
.ContentPadding(0.0f)
|
|
[
|
|
SAssignNew(ModeToolbarBox, SVerticalBox)
|
|
];
|
|
|
|
ModeToolbarTab = ToolbarTabRef;
|
|
SpawnOrUpdateModeToolbar();
|
|
return ToolbarTabRef;
|
|
|
|
}
|
|
|
|
void FModeToolkit::RequestModeUITabs()
|
|
{
|
|
if (ModeUILayer.IsValid())
|
|
{
|
|
TSharedPtr<FAssetEditorModeUILayer> ModeUILayerPtr = ModeUILayer.Pin();
|
|
PrimaryTabInfo.OnSpawnTab = FOnSpawnTab::CreateSP(SharedThis(this), &FModeToolkit::CreatePrimaryModePanel);
|
|
PrimaryTabInfo.TabLabel = LOCTEXT("ModesToolboxTab", "Mode Toolbox");
|
|
PrimaryTabInfo.TabTooltip = LOCTEXT("ModesToolboxTabTooltipText", "Open the Modes tab, which contains the active editor mode's settings.");
|
|
ModeUILayerPtr->SetModePanelInfo(UAssetEditorUISubsystem::TopLeftTabID, PrimaryTabInfo);
|
|
if (!HasIntegratedToolPalettes() && !HasToolkitBuilder())
|
|
{
|
|
|
|
ToolbarInfo.OnSpawnTab = FOnSpawnTab::CreateSP(SharedThis(this), &FModeToolkit::MakeModeToolbarTab);
|
|
ToolbarInfo.TabLabel = LOCTEXT("ModesToolbarTab", "Mode Toolbar");
|
|
ToolbarInfo.TabTooltip = LOCTEXT("LevelEditorModesToolbarTabTooltipText", "Opens a toolbar for the active editor mode");
|
|
ModeUILayerPtr->SetModePanelInfo(UAssetEditorUISubsystem::VerticalToolbarID, ToolbarInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FModeToolkit::OnModeIDChanged(const FEditorModeID& InID, bool bIsEntering)
|
|
{
|
|
if (const FEditorModeInfo* ModeInfo = GetEditorModeInfo())
|
|
{
|
|
if (ModeInfo->ID != NAME_None && ModeInfo->ID == InID && bIsEntering)
|
|
{
|
|
FToolkitManager::Get().RegisterNewToolkit(SharedThis(this));
|
|
}
|
|
}
|
|
}
|
|
|
|
const FEditorModeInfo* FModeToolkit::GetEditorModeInfo() const
|
|
{
|
|
if (const FEdMode* EdMode = GetEditorMode())
|
|
{
|
|
return &EdMode->GetModeInfo();
|
|
}
|
|
else if (OwningEditorMode.IsValid())
|
|
{
|
|
return &OwningEditorMode->GetModeInfo();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool FModeToolkit::ShouldShowModeToolbar() const
|
|
{
|
|
return ActiveToolBarRows.Num() > 0;
|
|
}
|
|
|
|
TSharedRef<SWidget> FModeToolkit::CreatePaletteWidget(TSharedPtr<FUICommandList> InCommandList, FName InToolbarCustomizationName, FName InPaletteName)
|
|
{
|
|
FUniformToolBarBuilder ModeToolbarBuilder(InCommandList, FMultiBoxCustomization(InToolbarCustomizationName));
|
|
ModeToolbarBuilder.SetStyle(&FAppStyle::Get(), "PaletteToolBar");
|
|
|
|
BuildToolPalette(InPaletteName, ModeToolbarBuilder);
|
|
|
|
return ModeToolbarBuilder.MakeWidget();
|
|
}
|
|
|
|
void FModeToolkit::SpawnOrUpdateModeToolbar()
|
|
{
|
|
if (ShouldShowModeToolbar())
|
|
{
|
|
if (ModeToolbarTab.IsValid())
|
|
{
|
|
RebuildModeToolBar();
|
|
}
|
|
else if (ModeUILayer.IsValid())
|
|
{
|
|
ModeUILayer.Pin()->GetTabManager()->TryInvokeTab(UAssetEditorUISubsystem::VerticalToolbarID);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FModeToolkit::RebuildModeToolBar()
|
|
{
|
|
TSharedPtr<SDockTab> ToolbarTabPtr = ModeToolbarTab.Pin();
|
|
if (ToolbarTabPtr && HasToolkitBuilder())
|
|
{
|
|
ToolbarTabPtr->SetParentDockTabStackTabWellHidden(true);
|
|
}
|
|
|
|
// If the tab or box is not valid the toolbar has not been opened or has been closed by the user
|
|
TSharedPtr<SVerticalBox> ModeToolbarBoxPinned = ModeToolbarBox.Pin();
|
|
if (ModeToolbarTab.IsValid() && ModeToolbarBoxPinned)
|
|
{
|
|
ModeToolbarBoxPinned->ClearChildren();
|
|
bool bExclusivePalettes = true;
|
|
TSharedRef<SVerticalBox> ToolBoxVBox = SNew(SVerticalBox);
|
|
|
|
TSharedRef< SUniformWrapPanel> PaletteTabBox = SNew(SUniformWrapPanel)
|
|
.SlotPadding(FMargin(1.f, 2.f))
|
|
.HAlign(HAlign_Left);
|
|
TSharedRef< SWidgetSwitcher > PaletteSwitcher = SNew(SWidgetSwitcher);
|
|
|
|
int32 PaletteCount = ActiveToolBarRows.Num();
|
|
if (PaletteCount > 0)
|
|
{
|
|
for (int32 RowIdx = 0; RowIdx < PaletteCount; ++RowIdx)
|
|
{
|
|
const FEdModeToolbarRow& Row = ActiveToolBarRows[RowIdx];
|
|
if (ensure(Row.ToolbarWidget.IsValid()))
|
|
{
|
|
TSharedRef<SWidget> PaletteWidget = Row.ToolbarWidget.ToSharedRef();
|
|
|
|
bExclusivePalettes = HasExclusiveToolPalettes();
|
|
|
|
if (!bExclusivePalettes)
|
|
{
|
|
ToolBoxVBox->AddSlot()
|
|
.AutoHeight()
|
|
.Padding(FMargin(2.0, 2.0))
|
|
[
|
|
SNew(SExpandableArea)
|
|
.AreaTitle(Row.DisplayName)
|
|
.AreaTitleFont(FAppStyle::Get().GetFontStyle("NormalFont"))
|
|
.BorderImage(FAppStyle::Get().GetBrush("PaletteToolbar.ExpandableAreaHeader"))
|
|
.BodyBorderImage(FAppStyle::Get().GetBrush("PaletteToolbar.ExpandableAreaBody"))
|
|
.HeaderPadding(FMargin(4.f))
|
|
.Padding(FMargin(4.0, 0.0))
|
|
.BodyContent()
|
|
[
|
|
PaletteWidget
|
|
]
|
|
];
|
|
}
|
|
else
|
|
{
|
|
// Don't show Palette Tabs if there is only one
|
|
if (PaletteCount > 1)
|
|
{
|
|
PaletteTabBox->AddSlot()
|
|
[
|
|
SNew(SCheckBox)
|
|
.Style(FAppStyle::Get(), "ToolPalette.DockingTab")
|
|
.OnCheckStateChanged_Lambda([PaletteSwitcher, Row, this](const ECheckBoxState) {
|
|
PaletteSwitcher->SetActiveWidget(Row.ToolbarWidget.ToSharedRef());
|
|
SetCurrentPalette(Row.PaletteName);
|
|
}
|
|
)
|
|
.IsChecked_Lambda([PaletteSwitcher, PaletteWidget]() -> ECheckBoxState { return PaletteSwitcher->GetActiveWidget() == PaletteWidget ? ECheckBoxState::Checked : ECheckBoxState::Unchecked; })
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(Row.DisplayName)
|
|
]
|
|
];
|
|
}
|
|
|
|
PaletteSwitcher->AddSlot()
|
|
[
|
|
PaletteWidget
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
ModeToolbarBoxPinned->AddSlot()
|
|
.AutoHeight()
|
|
[
|
|
SNew(SOverlay)
|
|
+ SOverlay::Slot()
|
|
[
|
|
SNew(SImage)
|
|
.Image(FAppStyle::GetBrush("ToolPalette.DockingWell"))
|
|
]
|
|
|
|
+ SOverlay::Slot()
|
|
[
|
|
PaletteTabBox
|
|
]
|
|
];
|
|
|
|
ModeToolbarBoxPinned->AddSlot()
|
|
.AutoHeight()
|
|
.Padding(1.f)
|
|
[
|
|
SNew(SBox)
|
|
.HeightOverride(PaletteSwitcher->GetNumWidgets() > 0 ? 45.f : 0.f)
|
|
[
|
|
PaletteSwitcher
|
|
]
|
|
];
|
|
|
|
ModeToolbarBoxPinned->AddSlot()
|
|
[
|
|
SNew(SScrollBox)
|
|
|
|
+ SScrollBox::Slot()
|
|
[
|
|
ToolBoxVBox
|
|
]
|
|
];
|
|
|
|
ModeToolbarPaletteSwitcher = PaletteSwitcher;
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|