void FPathContextMenu::MakeSetColorSubMenu(FMenuBuilder& MenuBuilder)
{
// New Color
MenuBuilder.AddMenuEntry(
LOCTEXT("NewColor", "New Color"),
LOCTEXT("NewColorTooltip", "Changes the color this folder should appear as."),
FSlateIcon(),
FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecutePickColor ) )
);
// Clear Color (only required if any of the selection has one)
if ( SelectedHasCustomColors() )
{
MenuBuilder.AddMenuEntry(
LOCTEXT("ClearColor", "Clear Color"),
LOCTEXT("ClearColorTooltip", "Resets the color this folder appears as."),
FSlateIcon(),
FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteResetColor ) )
);
}
// Add all the custom colors the user has chosen so far
TArray< FLinearColor > CustomColors;
if ( ContentBrowserUtils::HasCustomColors( &CustomColors ) )
{
MenuBuilder.BeginSection("PathContextCustomColors", LOCTEXT("CustomColorsExistingColors", "Existing Colors") );
{
for ( int32 ColorIndex = 0; ColorIndex < CustomColors.Num(); ColorIndex++ )
{
const FLinearColor& Color = CustomColors[ ColorIndex ];
MenuBuilder.AddWidget(
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.Padding(2, 0, 0, 0)
[
SNew(SButton)
.ButtonStyle( FEditorStyle::Get(), "Menu.Button" )
.OnClicked( this, &FPathContextMenu::OnColorClicked, Color )
[
SNew(SColorBlock)
.Color( Color )
.Size( FVector2D(77,16) )
]
],
LOCTEXT("CustomColor", ""),
/*bNoIndent=*/true
);
}
}
MenuBuilder.EndSection();
}
}
static void MakePostInfinityExtrapSubMenu(FMenuBuilder& MenuBuilder)
{
MenuBuilder.BeginSection( "Post-Infinity Extrapolation", LOCTEXT( "CurveEditorMenuPostInfinityExtrapHeader", "Extrapolation" ) );
{
MenuBuilder.AddMenuEntry( FRichCurveEditorCommands::Get().SetPostInfinityExtrapCycle);
MenuBuilder.AddMenuEntry( FRichCurveEditorCommands::Get().SetPostInfinityExtrapCycleWithOffset);
MenuBuilder.AddMenuEntry( FRichCurveEditorCommands::Get().SetPostInfinityExtrapOscillate);
MenuBuilder.AddMenuEntry( FRichCurveEditorCommands::Get().SetPostInfinityExtrapLinear);
MenuBuilder.AddMenuEntry( FRichCurveEditorCommands::Get().SetPostInfinityExtrapConstant);
}
MenuBuilder.EndSection();
}
/** Generates a lighting tools sub-menu */
static void MakeLightingToolsMenu( FMenuBuilder& InMenuBuilder )
{
InMenuBuilder.BeginSection("LevelEditorBuildLightingTools", LOCTEXT( "LightingToolsHeading", "Light Environments" ) );
{
InMenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LightingTools_ShowBounds );
InMenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LightingTools_ShowTraces );
InMenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LightingTools_ShowDirectOnly );
InMenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LightingTools_ShowIndirectOnly );
InMenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LightingTools_ShowIndirectSamples );
}
InMenuBuilder.EndSection();
}
static void BuildViewOptionsMenu(FMenuBuilder& Menu)
{
Menu.BeginSection("CascadeViewOverlays", NSLOCTEXT("Cascade", "ViewOptionsHeader", "View Overlays"));
{
Menu.AddMenuEntry(FCascadeCommands::Get().View_ParticleCounts);
Menu.AddMenuEntry(FCascadeCommands::Get().View_ParticleEventCounts);
Menu.AddMenuEntry(FCascadeCommands::Get().View_ParticleTimes);
Menu.AddMenuEntry(FCascadeCommands::Get().View_ParticleMemory);
Menu.AddMenuEntry(FCascadeCommands::Get().View_SystemCompleted);
}
Menu.EndSection();
}
static void BuildAnimSpeedOptionsMenu(FMenuBuilder& Menu)
{
Menu.BeginSection("CascadeAnimSpeed", NSLOCTEXT("Cascade", "AnimSpeedHeader", "AnimSpeed"));
{
Menu.AddMenuEntry(FCascadeCommands::Get().AnimSpeed_100);
Menu.AddMenuEntry(FCascadeCommands::Get().AnimSpeed_50);
Menu.AddMenuEntry(FCascadeCommands::Get().AnimSpeed_25);
Menu.AddMenuEntry(FCascadeCommands::Get().AnimSpeed_10);
Menu.AddMenuEntry(FCascadeCommands::Get().AnimSpeed_1);
}
Menu.EndSection();
}
void FCollectionContextMenu::MakeSaveDynamicCollectionSubMenu(FMenuBuilder& MenuBuilder, FText InSearchQuery)
{
auto OnCollectionCreated = FCollectionItem::FCollectionCreatedEvent::CreateSP(this, &FCollectionContextMenu::ExecuteSaveDynamicCollection, InSearchQuery);
// Create new root level collection
MakeNewCollectionSubMenu(MenuBuilder, ECollectionStorageMode::Dynamic, SCollectionView::FCreateCollectionPayload(OnCollectionCreated));
FCollectionManagerModule& CollectionManagerModule = FCollectionManagerModule::GetModule();
TArray<FCollectionNameType> AvailableCollections;
CollectionManagerModule.Get().GetCollections(AvailableCollections);
AvailableCollections.Sort([](const FCollectionNameType& One, const FCollectionNameType& Two) -> bool
{
return One.Name < Two.Name;
});
if (AvailableCollections.Num() > 0)
{
MenuBuilder.BeginSection("CollectionReplaceCollection", LOCTEXT("OverwriteDynamicCollectionMenuHeading", "Overwrite Dynamic Collection"));
for (const FCollectionNameType& AvailableCollection : AvailableCollections)
{
// Never display system collections
if (AvailableCollection.Type == ECollectionShareType::CST_System)
{
continue;
}
// Can only overwrite dynamic collections
ECollectionStorageMode::Type StorageMode = ECollectionStorageMode::Static;
CollectionManagerModule.Get().GetCollectionStorageMode(AvailableCollection.Name, AvailableCollection.Type, StorageMode);
if (StorageMode != ECollectionStorageMode::Dynamic)
{
continue;
}
MenuBuilder.AddMenuEntry(
FText::FromName(AvailableCollection.Name),
FText::Format(LOCTEXT("SaveDynamicCollection_OverwriteExistingCollectionToolTip", "Overwrite '{0}' with the current search query"), FText::FromName(AvailableCollection.Name)),
FSlateIcon(FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName(AvailableCollection.Type)),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteSaveDynamicCollection, AvailableCollection, InSearchQuery ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteSaveDynamicCollection, AvailableCollection )
)
);
}
MenuBuilder.EndSection();
}
}
static void CreateLODGroupActionsSubMenu(FMenuBuilder& MenuBuilder, TArray<FAssetData> SelectedAssets)
{
MenuBuilder.BeginSection("Simplygon", LOCTEXT("SimplygonHeading", "Simplygon"));
{
MenuBuilder.AddSubMenu(
LOCTEXT("LODGroupSubMenu", "Assign LOD Group"),
LOCTEXT("LODGroupSubMenu_ToolTip", "Assign LODGroup to selection"),
FNewMenuDelegate::CreateStatic(&PopulateLODGroupMenu, SelectedAssets),
false,
FSlateIcon(FEditorStyle::GetStyleSetName(), "SimplygonIcon.TabIcon"));
}
MenuBuilder.EndSection();
}
static void ExtendMenu( FMenuBuilder& MenuBuilder )
{
// one extra entry when summoning the menu this way
MenuBuilder.BeginSection("ActorPreview", LOCTEXT("PreviewHeading", "Preview") );
{
// Note: not using a command for play from here since it requires a mouse click
FUIAction PlayFromHereAction(
FExecuteAction::CreateStatic( &FPlayWorldCommandCallbacks::StartPlayFromHere ) );
const FText PlayFromHereLabel = GEditor->OnlyLoadEditorVisibleLevelsInPIE() ? LOCTEXT("PlayFromHereVisible", "Play From Here (visible levels)") : LOCTEXT("PlayFromHere", "Play From Here");
MenuBuilder.AddMenuEntry( PlayFromHereLabel, LOCTEXT("PlayFromHere_ToolTip", "Starts a game preview from the clicked location"),FSlateIcon(), PlayFromHereAction );
}
MenuBuilder.EndSection();
}
//------------------------------------------------------------------------------
void SBlueprintFavoritesPalette::GenerateContextMenuEntries(FMenuBuilder& MenuBuilder) const
{
FBlueprintFavoritesPaletteCommands const& PaletteCommands = FBlueprintFavoritesPaletteCommands::Get();
MenuBuilder.BeginSection("FavoritedItem");
{
TSharedPtr<FEdGraphSchemaAction> SelectedAction = GetSelectedAction();
// if we have a specific action selected
if (SelectedAction.IsValid())
{
MenuBuilder.AddMenuEntry(PaletteCommands.RemoveSingleFavorite);
}
// if we have a category selected
{
FString CategoryName = GraphActionMenu->GetSelectedCategoryName();
// make sure it is an actual category and isn't the root (assume there's only one category with that name)
if (!CategoryName.IsEmpty() && (CategoryName != SBlueprintFavoritesPaletteUtils::FavoritesCategoryName))
{
MenuBuilder.AddMenuEntry(PaletteCommands.RemoveSubFavorites);
}
}
}
MenuBuilder.EndSection();
MenuBuilder.BeginSection("FavoritesList");
{
SBlueprintSubPalette::GenerateContextMenuEntries(MenuBuilder);
MenuBuilder.AddSubMenu(
LOCTEXT("LoadProfile", "Load Profile"),
LOCTEXT("LoadProfileTooltip", "Replace your current favorites with ones from a pre-defined profile."),
FNewMenuDelegate::CreateStatic(&SBlueprintFavoritesPaletteUtils::BuildProfilesSubMenu)
);
MenuBuilder.AddMenuEntry(PaletteCommands.ClearFavorites);
}
MenuBuilder.EndSection();
}
void SVisualLogger::FillFileMenu(FMenuBuilder& MenuBuilder, const TSharedPtr<FTabManager> InTabManager)
{
MenuBuilder.BeginSection("LogFile", LOCTEXT("FileMenu", "Log File"));
{
MenuBuilder.AddMenuEntry(FVisualLoggerCommands::Get().LoadFromVLog);
MenuBuilder.AddMenuEntry(FVisualLoggerCommands::Get().SaveToVLog);
}
MenuBuilder.EndSection();
MenuBuilder.BeginSection("LogFilters", LOCTEXT("FIlterMenu", "Log Filters"));
{
MenuBuilder.AddSubMenu(
LOCTEXT("LoadPreset", "Load Preset"), LOCTEXT("LoadPresetTooltip", "Load filter's preset"),
FNewMenuDelegate::CreateRaw(this, &SVisualLogger::FillLoadPresetMenu));
MenuBuilder.AddMenuEntry(
LOCTEXT("SavePreset", "Save Preset"), LOCTEXT("SavePresetTooltip", "Save filter's setting as preset"),
FSlateIcon(), FUIAction(
FExecuteAction::CreateLambda(
[this](){
}
)));
}
MenuBuilder.EndSection();
}
void FMainMenu::FillHelpMenu( FMenuBuilder& MenuBuilder, const TSharedRef< FExtender > Extender )
{
MenuBuilder.BeginSection("HelpOnline", NSLOCTEXT("MainHelpMenu", "Online", "Online"));
{
MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().VisitForums);
MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().VisitSearchForAnswersPage);
MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().VisitWiki);
const FText SupportWebSiteLabel = NSLOCTEXT("MainHelpMenu", "VisitUnrealEngineSupportWebSite", "Unreal Engine Support Web Site...");
MenuBuilder.AddMenuSeparator("EpicGamesHelp");
MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().VisitEpicGamesDotCom, "VisitEpicGamesDotCom");
}
MenuBuilder.EndSection();
MenuBuilder.BeginSection("HelpApplication", NSLOCTEXT("MainHelpMenu", "Application", "Application"));
{
const FText AboutWindowTitle = NSLOCTEXT("MainHelpMenu", "AboutUnrealEditor", "About Unreal Editor...");
MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().AboutUnrealEd, "AboutUnrealEd", AboutWindowTitle);
}
MenuBuilder.EndSection();
}
static void BuildLandscapeVisualizersMenu(FMenuBuilder& InMenuBuilder)
{
const FLandscapeEditorCommands& LandscapeActions = FLandscapeEditorCommands::Get();
InMenuBuilder.BeginSection("LandscapeVisualizers", LOCTEXT("LandscapeHeader", "Landscape Visualizers"));
{
InMenuBuilder.AddMenuEntry(LandscapeActions.ViewModeNormal, NAME_None, LOCTEXT("LandscapeViewModeNormal", "Normal"));
InMenuBuilder.AddMenuEntry(LandscapeActions.ViewModeLOD, NAME_None, LOCTEXT("LandscapeViewModeLOD", "LOD"));
InMenuBuilder.AddMenuEntry(LandscapeActions.ViewModeLayerDensity, NAME_None, LOCTEXT("LandscapeViewModeLayerDensity", "Layer Density"));
if (GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_Landscape))
{
InMenuBuilder.AddMenuEntry(LandscapeActions.ViewModeLayerDebug, NAME_None, LOCTEXT("LandscapeViewModeLayerDebug", "Layer Debug"));
}
InMenuBuilder.AddMenuEntry(LandscapeActions.ViewModeWireframeOnTop, NAME_None, LOCTEXT("LandscapeViewModeWireframeOnTop", "Wireframe on Top"));
}
InMenuBuilder.EndSection();
}
void FCollectionContextMenu::MakeCollectionShareTypeSubMenu(FMenuBuilder& MenuBuilder)
{
MenuBuilder.BeginSection("CollectionShareType", LOCTEXT("CollectionShareTypeMenuHeading", "Collection Share Type"));
{
MenuBuilder.AddMenuEntry(
ECollectionShareType::ToText( ECollectionShareType::CST_Shared ),
ECollectionShareType::GetDescription( ECollectionShareType::CST_Shared ),
FSlateIcon( FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName( ECollectionShareType::CST_Shared ) ),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteSetCollectionShareType, ECollectionShareType::CST_Shared ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteSetCollectionShareType, ECollectionShareType::CST_Shared ),
FIsActionChecked::CreateSP( this, &FCollectionContextMenu::IsSetCollectionShareTypeChecked, ECollectionShareType::CST_Shared )
),
NAME_None,
EUserInterfaceActionType::Check
);
MenuBuilder.AddMenuEntry(
ECollectionShareType::ToText( ECollectionShareType::CST_Private ),
ECollectionShareType::GetDescription( ECollectionShareType::CST_Private ),
FSlateIcon( FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName( ECollectionShareType::CST_Private ) ),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteSetCollectionShareType, ECollectionShareType::CST_Private ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteSetCollectionShareType, ECollectionShareType::CST_Private ),
FIsActionChecked::CreateSP( this, &FCollectionContextMenu::IsSetCollectionShareTypeChecked, ECollectionShareType::CST_Private )
),
NAME_None,
EUserInterfaceActionType::Check
);
MenuBuilder.AddMenuEntry(
ECollectionShareType::ToText( ECollectionShareType::CST_Local ),
ECollectionShareType::GetDescription( ECollectionShareType::CST_Local ),
FSlateIcon( FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName( ECollectionShareType::CST_Local ) ),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteSetCollectionShareType, ECollectionShareType::CST_Local ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteSetCollectionShareType, ECollectionShareType::CST_Local ),
FIsActionChecked::CreateSP( this, &FCollectionContextMenu::IsSetCollectionShareTypeChecked, ECollectionShareType::CST_Local )
),
NAME_None,
EUserInterfaceActionType::Check
);
}
MenuBuilder.EndSection();
}
void FWidgetBlueprintEditor::ExtendSequencerAddTrackMenu( FMenuBuilder& AddTrackMenuBuilder, TArray<UObject*> ContextObjects )
{
if ( ContextObjects.Num() == 1 )
{
UWidget* Widget = Cast<UWidget>( ContextObjects[0] );
if ( Widget != nullptr && Widget->GetParent() != nullptr && Widget->Slot != nullptr )
{
AddTrackMenuBuilder.BeginSection( "Slot", LOCTEXT( "SlotSection", "Slot" ) );
{
FUIAction AddSlotAction( FExecuteAction::CreateRaw( this, &FWidgetBlueprintEditor::AddSlotTrack, Widget->Slot ) );
FText AddSlotLabel = FText::Format(LOCTEXT("SlotLabelFormat", "{0} Slot"), FText::FromString(Widget->GetParent()->GetName()));
FText AddSlotToolTip = FText::Format(LOCTEXT("SlotToolTipFormat", "Add {0} slot"), FText::FromString( Widget->GetParent()->GetName()));
AddTrackMenuBuilder.AddMenuEntry(AddSlotLabel, AddSlotToolTip, FSlateIcon(), AddSlotAction);
}
AddTrackMenuBuilder.EndSection();
}
}
}
void SVisualLogger::FillLoadPresetMenu(FMenuBuilder& MenuBuilder)
{
ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>();
MenuBuilder.BeginSection("FilterPresets", LOCTEXT("FilterPresets", "Presets"));
#if 0 //disabled for now, we don't use presets yet
for (auto& CurrentPreset : Settings->FilterPresets)
{
MenuBuilder.AddMenuEntry(
FText::FromString(CurrentPreset.FilterName), LOCTEXT("LoadPresetTooltip", "Load filter's preset"),
FSlateIcon(), FUIAction(
FExecuteAction::CreateLambda([this, CurrentPreset](){ this->SetFiltersPreset(CurrentPreset); }
))
);
}
#endif
MenuBuilder.EndSection();
}
void FTranslationEditorMenu::FillTranslationMenu( FMenuBuilder& MenuBuilder/*, FTranslationEditor& TranslationEditor*/ )
{
MenuBuilder.BeginSection("Font", LOCTEXT("Translation_FontHeading", "Font"));
{
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().ChangeSourceFont );
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().ChangeTranslationTargetFont );
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().PreviewAllTranslationsInEditor );
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().ImportLatestFromLocalizationService );
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().ExportToPortableObjectFormat );
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().ImportFromPortableObjectFormat );
MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().OpenSearchTab );
if (GetDefault<UEditorExperimentalSettings>()->bEnableTranslationPicker)
{
MenuBuilder.AddMenuEntry(FTranslationEditorCommands::Get().OpenTranslationPicker);
}
}
MenuBuilder.EndSection();
}
static void FillRecentFileAndExitMenuItems( FMenuBuilder& MenuBuilder )
{
MenuBuilder.BeginSection( "FileRecentFiles" );
{
if ( FMainFrameActionCallbacks::ProjectNames.Num() > 0 )
{
MenuBuilder.AddSubMenu(
LOCTEXT("SwitchProjectSubMenu", "Recent Projects"),
LOCTEXT("SwitchProjectSubMenu_ToolTip", "Select a project to switch to"),
FNewMenuDelegate::CreateStatic( &FRecentProjectsMenu::MakeMenu ), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "MainFrame.RecentProjects")
);
}
}
MenuBuilder.EndSection();
MenuBuilder.AddMenuSeparator();
MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().Exit, "Exit" );
}
void FSequencerFolderNode::BuildContextMenu(FMenuBuilder& MenuBuilder)
{
FSequencerDisplayNode::BuildContextMenu(MenuBuilder);
TSharedRef<FSequencerFolderNode> ThisNode = SharedThis(this);
MenuBuilder.BeginSection("Folder", LOCTEXT("FolderContextMenuSectionName", "Folder"));
{
MenuBuilder.AddMenuEntry(
LOCTEXT("SetColor", "Set Color"),
LOCTEXT("SetColorTooltip", "Set the folder color"),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP(this, &FSequencerFolderNode::SetFolderColor))
);
}
MenuBuilder.EndSection();
}
void FCollectionContextMenu::MakeNewCollectionSubMenu(FMenuBuilder& MenuBuilder, ECollectionStorageMode::Type StorageMode, SCollectionView::FCreateCollectionPayload InCreationPayload)
{
const FText MenuHeading = FText::Format(
(InCreationPayload.ParentCollection.IsSet()) ? LOCTEXT("NewXChildCollectionMenuHeading", "New {0} Child Collection") : LOCTEXT("NewXCollectionMenuHeading", "New {0} Collection"),
ECollectionStorageMode::ToText(StorageMode)
);
MenuBuilder.BeginSection("CollectionNewCollection", MenuHeading);
{
const bool bCanCreateSharedChildren = !InCreationPayload.ParentCollection.IsSet() || ECollectionShareType::IsValidChildType( InCreationPayload.ParentCollection->Type, ECollectionShareType::CST_Shared );
MenuBuilder.AddMenuEntry(
LOCTEXT("NewCollection_Shared", "Shared Collection"),
LOCTEXT("NewCollection_SharedTooltip", "Create a collection that can be seen by anyone."),
FSlateIcon( FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName( ECollectionShareType::CST_Shared ) ),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteNewCollection, ECollectionShareType::CST_Shared, StorageMode, InCreationPayload ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteNewCollection, ECollectionShareType::CST_Shared, bCanCreateSharedChildren )
)
);
const bool bCanCreatePrivateChildren = !InCreationPayload.ParentCollection.IsSet() || ECollectionShareType::IsValidChildType( InCreationPayload.ParentCollection->Type, ECollectionShareType::CST_Private );
MenuBuilder.AddMenuEntry(
LOCTEXT("NewCollection_Private", "Private Collection"),
LOCTEXT("NewCollection_PrivateTooltip", "Create a collection that can only be seen by you."),
FSlateIcon( FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName( ECollectionShareType::CST_Private ) ),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteNewCollection, ECollectionShareType::CST_Private, StorageMode, InCreationPayload ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteNewCollection, ECollectionShareType::CST_Private, bCanCreatePrivateChildren )
)
);
const bool bCanCreateLocalChildren = !InCreationPayload.ParentCollection.IsSet() || ECollectionShareType::IsValidChildType( InCreationPayload.ParentCollection->Type, ECollectionShareType::CST_Local );
MenuBuilder.AddMenuEntry(
LOCTEXT("NewCollection_Local", "Local Collection"),
LOCTEXT("NewCollection_LocalTooltip", "Create a collection that is not in source control and can only be seen by you."),
FSlateIcon( FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName( ECollectionShareType::CST_Local ) ),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteNewCollection, ECollectionShareType::CST_Local, StorageMode, InCreationPayload ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteNewCollection, ECollectionShareType::CST_Local, bCanCreateLocalChildren )
)
);
}
MenuBuilder.EndSection();
}
void FStreamingLevelCollectionModel::CustomizeFileMainMenu(FMenuBuilder& InMenuBuilder) const
{
FLevelCollectionModel::CustomizeFileMainMenu(InMenuBuilder);
const FLevelCollectionCommands& Commands = FLevelCollectionCommands::Get();
InMenuBuilder.BeginSection("LevelsAddLevel");
{
InMenuBuilder.AddSubMenu(
LOCTEXT("LevelsStreamingMethod", "Default Streaming Method"),
LOCTEXT("LevelsStreamingMethod_Tooltip", "Changes the default streaming method for a new levels"),
FNewMenuDelegate::CreateRaw(this, &FStreamingLevelCollectionModel::FillDefaultStreamingMethodSubMenu ) );
InMenuBuilder.AddMenuEntry( Commands.World_CreateEmptyLevel );
InMenuBuilder.AddMenuEntry( Commands.World_AddExistingLevel );
InMenuBuilder.AddMenuEntry( Commands.World_AddSelectedActorsToNewLevel );
InMenuBuilder.AddMenuEntry( Commands.World_MergeSelectedLevels );
}
InMenuBuilder.EndSection();
}
static void FillRecentFileAndExitMenuItems( FMenuBuilder& MenuBuilder )
{
MenuBuilder.BeginSection("FileRecentFiles");
{
if (GetDefault<UEditorStyleSettings>()->bShowProjectMenus && FMainFrameActionCallbacks::ProjectNames.Num() > 0)
{
MenuBuilder.AddSubMenu(
LOCTEXT("SwitchProjectSubMenu", "Recent Projects"),
LOCTEXT("SwitchProjectSubMenu_ToolTip", "Select a project to switch to"),
FNewMenuDelegate::CreateStatic(&FRecentProjectsMenu::MakeMenu), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "MainFrame.RecentProjects")
);
}
}
MenuBuilder.EndSection();
#if !PLATFORM_MAC // Handled by app's menu in menu bar
MenuBuilder.AddMenuSeparator();
MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().Exit, "Exit" );
#endif
}
void OnAutomationToolsMenuCreation(FMenuBuilder& MenuBuilder)
{
MenuBuilder.BeginSection("Testing", LOCTEXT("Testing", "Testing"));
MenuBuilder.AddMenuEntry(
LOCTEXT("AutomationLabel", "Test Automation"),
LOCTEXT("Tooltip", "Launch the Testing Automation Frontend."),
FSlateIcon(FEditorStyle::GetStyleSetName(), "AutomationTools.MenuIcon"),
FUIAction(FExecuteAction::CreateStatic(&FEditorAutomationModule::OnShowAutomationFrontend)));
MenuBuilder.EndSection();
// TODO Come up with a way to hide this if no tools are registered.
if (WorkspaceMenu::GetMenuStructure().GetAutomationToolsCategory()->GetChildItems().Num() > 0)
{
MenuBuilder.AddSubMenu(
LOCTEXT("AutomationTools", "Automation Tools"),
LOCTEXT("AutomationToolsToolTip", "Assorted tools to help generate data for some of the automation tests."),
FNewMenuDelegate::CreateRaw(this, &FEditorAutomationModule::PopulateAutomationTools)
);
}
}
void FHistoryManager::GetAvailableHistoryMenuItems(bool bGetPrior, FMenuBuilder& MenuBuilder)
{
const FText HistoryHeadingString = (bGetPrior)? LOCTEXT("BackHistory", "Back History") : LOCTEXT("NextHistory", "Next History");
MenuBuilder.BeginSection("HistoryBackNext", HistoryHeadingString);
{
if (HistoryData.Num() > 1)
{
// if there is at least 2 history items...
// Start index is the first snapshot we should make a menu item out of
int32 StartIndex = 0;
// EndIndex is the last snapshot we should make a menu item out of
int32 EndIndex = CurrentHistoryIndex;
if (!bGetPrior)
{
// Need to return only items on or after the current history index
StartIndex = CurrentHistoryIndex;
EndIndex = HistoryData.Num() - 1;
}
// Check to make sure the start and end indices are within the bounds of the history list
if (StartIndex < HistoryData.Num() && EndIndex != -1)
{
// Get all menu items between and including the start index and end index
for (int32 HistoryIdx = StartIndex; HistoryIdx <= EndIndex; ++HistoryIdx)
{
MenuBuilder.AddMenuEntry(
FText::FromString( HistoryData[HistoryIdx].HistoryDesc ),
FText(),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateRaw( this, &FHistoryManager::ExecuteJumpToHistory, HistoryIdx )
)
);
}
}
}
}
MenuBuilder.EndSection();
}
void FSequencerAssetEditor::ExtendSequencerAddTrackMenu( FMenuBuilder& AddTrackMenuBuilder, TArray<UObject*> ContextObjects )
{
if ( ContextObjects.Num() == 1 )
{
AActor* Actor = Cast<AActor>( ContextObjects[0] );
if ( Actor != nullptr )
{
AddTrackMenuBuilder.BeginSection( "Components", LOCTEXT( "ComponentsSection", "Components" ) );
{
for ( UActorComponent* Component : Actor->GetComponents() )
{
FUIAction AddComponentAction( FExecuteAction::CreateSP( this, &FSequencerAssetEditor::AddComponentTrack, Component ) );
FText AddComponentLabel = FText::FromString(Component->GetName());
FText AddComponentToolTip = FText::Format( LOCTEXT( "ComponentToolTipFormat", "Add {0} component" ), FText::FromString( Component->GetName() ) );
AddTrackMenuBuilder.AddMenuEntry( AddComponentLabel, AddComponentToolTip, FSlateIcon(), AddComponentAction );
}
}
AddTrackMenuBuilder.EndSection();
}
}
}
/** Generates a lighting info dialogs sub-menu */
static void MakeLightingInfoMenu( FMenuBuilder& InMenuBuilder )
{
InMenuBuilder.BeginSection("LevelEditorBuildLightingInfo", LOCTEXT( "LightingInfoHeading", "Lighting Info Dialogs" ) );
{
InMenuBuilder.AddSubMenu(
LOCTEXT( "LightingToolsSubMenu", "Lighting Tools" ),
LOCTEXT( "LightingToolsSubMenu_ToolTip", "Shows the Lighting Tools options." ),
FNewMenuDelegate::CreateStatic( &FLightingMenus::MakeLightingToolsMenu ) );
InMenuBuilder.AddSubMenu(
LOCTEXT( "LightingDensityRenderingSubMenu", "LightMap Density Rendering Options" ),
LOCTEXT( "LightingDensityRenderingSubMenu_ToolTip", "Shows the LightMap Density Rendering viewmode options." ),
FNewMenuDelegate::CreateStatic( &FLightingMenus::MakeLightingDensityMenu ) );
InMenuBuilder.AddSubMenu(
LOCTEXT( "LightingResolutionAdjustmentSubMenu", "LightMap Resolution Adjustment" ),
LOCTEXT( "LightingResolutionAdjustmentSubMenu_ToolTip", "Shows the LightMap Resolution Adjustment options." ),
FNewMenuDelegate::CreateStatic( &FLightingMenus::MakeLightingResolutionMenu ) );
InMenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LightingStaticMeshInfo, NAME_None, LOCTEXT( "BuildLightingInfo_LightingStaticMeshInfo", "Lighting StaticMesh Info..." ) );
}
InMenuBuilder.EndSection();
}
void FFrontendFilter_ArbitraryComparisonOperation::ModifyContextMenu(FMenuBuilder& MenuBuilder)
{
FUIAction Action;
MenuBuilder.BeginSection(TEXT("ComparsionSection"), LOCTEXT("ComparisonSectionHeading", "AssetRegistrySearchable Comparison"));
TSharedRef<SWidget> KeyWidget =
SNew(SEditableTextBox)
.Text_Raw(this, &FFrontendFilter_ArbitraryComparisonOperation::GetKeyValueAsText)
.OnTextCommitted_Raw(this, &FFrontendFilter_ArbitraryComparisonOperation::OnKeyValueTextCommitted)
.MinDesiredWidth(100.0f);
TSharedRef<SWidget> ValueWidget = SNew(SEditableTextBox)
.Text_Raw(this, &FFrontendFilter_ArbitraryComparisonOperation::GetTargetValueAsText)
.OnTextCommitted_Raw(this, &FFrontendFilter_ArbitraryComparisonOperation::OnTargetValueTextCommitted)
.MinDesiredWidth(100.0f);
MenuBuilder.AddWidget(KeyWidget, LOCTEXT("KeyMenuDesc", "Tag"));
MenuBuilder.AddWidget(ValueWidget, LOCTEXT("ValueMenuDesc", "Target Value"));
#define UE_SET_COMP_OP(Operation) \
MenuBuilder.AddMenuEntry(FText::AsCultureInvariant(ConvertOperationToString(Operation)), \
LOCTEXT("SwitchOpsTooltip", "Switch comparsion type"), \
FSlateIcon(), \
FUIAction(FExecuteAction::CreateRaw(this, &FFrontendFilter_ArbitraryComparisonOperation::SetComparisonOperation, Operation), FCanExecuteAction(), FIsActionChecked::CreateRaw(this, &FFrontendFilter_ArbitraryComparisonOperation::IsComparisonOperationEqualTo, Operation)), \
NAME_None, \
EUserInterfaceActionType::RadioButton);
UE_SET_COMP_OP(ETextFilterComparisonOperation::Equal);
UE_SET_COMP_OP(ETextFilterComparisonOperation::NotEqual);
UE_SET_COMP_OP(ETextFilterComparisonOperation::Less);
UE_SET_COMP_OP(ETextFilterComparisonOperation::LessOrEqual);
UE_SET_COMP_OP(ETextFilterComparisonOperation::Greater);
UE_SET_COMP_OP(ETextFilterComparisonOperation::GreaterOrEqual);
#undef UE_SET_COMP_OP
MenuBuilder.EndSection();
}
bool FAssetContextMenu::AddCollectionMenuOptions(FMenuBuilder& MenuBuilder)
{
// "Remove from collection" (only display option if exactly one collection is selected)
if ( SourcesData.Collections.Num() == 1 )
{
MenuBuilder.BeginSection("AssetContextCollections", LOCTEXT("AssetCollectionOptionsMenuHeading", "Collections"));
{
MenuBuilder.AddMenuEntry(
LOCTEXT("RemoveFromCollection", "Remove From Collection"),
LOCTEXT("RemoveFromCollection_ToolTip", "Removes the selected asset from the current collection."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteRemoveFromCollection ),
FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteRemoveFromCollection )
)
);
}
MenuBuilder.EndSection();
return true;
}
return false;
}
void FCollectionContextMenu::MakeNewCollectionSubMenu(FMenuBuilder& MenuBuilder)
{
MenuBuilder.BeginSection("CollectionNewCollection", LOCTEXT("NewCollectionMenuHeading", "New Collection"));
{
MenuBuilder.AddMenuEntry(
LOCTEXT("NewCollection_Shared", "Shared Collection"),
LOCTEXT("NewCollection_SharedTooltip", "Create a collection that can be seen by anyone."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteNewCollection, ECollectionShareType::CST_Shared ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteNewCollection, ECollectionShareType::CST_Shared )
)
);
MenuBuilder.AddMenuEntry(
LOCTEXT("NewCollection_Private", "Private Collection"),
LOCTEXT("NewCollection_PrivateTooltip", "Create a collection that can only be seen by you."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteNewCollection, ECollectionShareType::CST_Private ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteNewCollection, ECollectionShareType::CST_Private )
)
);
MenuBuilder.AddMenuEntry(
LOCTEXT("NewCollection_Local", "Local Collection"),
LOCTEXT("NewCollection_LocalTooltip", "Create a collection that is not in source control and can only be seen by you."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteNewCollection, ECollectionShareType::CST_Local ),
FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteNewCollection, ECollectionShareType::CST_Local )
)
);
}
MenuBuilder.EndSection();
}
bool FAssetContextMenu::AddReferenceMenuOptions(FMenuBuilder& MenuBuilder)
{
MenuBuilder.BeginSection("AssetContextReferences", LOCTEXT("ReferencesMenuHeading", "References"));
{
MenuBuilder.AddMenuEntry(
LOCTEXT("CopyReference", "Copy Reference"),
LOCTEXT("CopyReferenceTooltip", "Copies reference paths for the selected assets to the clipboard."),
FSlateIcon(),
FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteCopyReference ) )
);
MenuBuilder.AddMenuEntry(
LOCTEXT("ReferenceViewer", "Reference Viewer..."),
LOCTEXT("ReferenceViewerTooltip", "Shows a graph of references for this asset."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteShowReferenceViewer )
)
);
}
MenuBuilder.EndSection();
return true;
}
void FLevelEditorContextMenuImpl::FillMatineeSelectActorMenu( FMenuBuilder& MenuBuilder )
{
MenuBuilder.BeginSection("SelectMatinee", LOCTEXT("SelectMatineeHeading", "Matinee") );
{
// show list of Matinee Actors that controls this actor
// this is ugly but we don't have good way of knowing which Matinee actor controls me
// in the future this can be cached to TMap somewhere and use that list
// for now we show only when 1 actor is selected
if ( SelectionInfo.SharedLevel && SelectionInfo.NumSelected == 1 )
{
TArray<AMatineeActor*> MatineeActors;
// first collect all matinee actors
for ( AActor* Actor : SelectionInfo.SharedLevel->Actors )
{
AMatineeActor * CurActor = Cast<AMatineeActor>(Actor);
if ( CurActor )
{
MatineeActors.Add(CurActor);
}
}
if ( MatineeActors.Num() > 0 )
{
FSelectionIterator ActorIter( GEditor->GetSelectedActorIterator() );
AActor* SelectedActor = Cast<AActor>(*ActorIter);
// now delete the matinee actors that don't control currently selected actor
for (int32 MatineeActorIter=0; MatineeActorIter<MatineeActors.Num(); ++MatineeActorIter)
{
AMatineeActor * CurMatineeActor = MatineeActors[MatineeActorIter];
TArray<AActor *> CutMatineeControlledActors;
CurMatineeActor->GetControlledActors(CutMatineeControlledActors);
bool bIsMatineeControlled=false;
for ( AActor* ControlledActor : CutMatineeControlledActors )
{
if (ControlledActor == SelectedActor)
{
bIsMatineeControlled = true;
}
}
// if not, remove it
if (!bIsMatineeControlled)
{
MatineeActors.RemoveAt(MatineeActorIter);
--MatineeActorIter;
}
}
// if some matinee controls this, add to menu for direct selection
if ( MatineeActors.Num() > 0 )
{
for (int32 MatineeActorIter=0; MatineeActorIter<MatineeActors.Num(); ++MatineeActorIter)
{
AMatineeActor * CurMatineeActor = MatineeActors[MatineeActorIter];
const FText Text = FText::Format( LOCTEXT("SelectMatineeActor", "Select {0}"), FText::FromString( CurMatineeActor->GetName() ) );
FUIAction CurMatineeActorAction( FExecuteAction::CreateStatic( &FLevelEditorActionCallbacks::OnSelectMatineeActor, CurMatineeActor ) );
MenuBuilder.AddMenuEntry( Text, Text, FSlateIcon(), CurMatineeActorAction );
// if matinee is opened, and if that is CurMatineeActor, show option to go to group
if( GLevelEditorModeTools().IsModeActive( FBuiltinEditorModes::EM_InterpEdit ) )
{
const FEdModeInterpEdit* InterpEditMode = (const FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
if ( InterpEditMode && InterpEditMode->MatineeActor == CurMatineeActor )
{
FUIAction SelectedActorAction( FExecuteAction::CreateStatic( &FLevelEditorActionCallbacks::OnSelectMatineeGroup, SelectedActor ) );
MenuBuilder.AddMenuEntry( LOCTEXT("SelectMatineeGroupForActorMenuTitle", "Select Matinee Group For This Actor"), LOCTEXT("SelectMatineeGroupForActorMenuTooltip", "Selects matinee group controlling this actor"), FSlateIcon(), SelectedActorAction );
}
}
}
}
}
}
// if this class is Matinee Actor, add option to allow select all controlled actors
if ( SelectionInfo.bHaveMatinee )
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().SelectAllActorsControlledByMatinee );
}
}
MenuBuilder.EndSection();
}
