void FAssetTypeActions_SoundWave::GetActions( const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder )
{
FAssetTypeActions_SoundBase::GetActions(InObjects, MenuBuilder);
auto SoundNodes = GetTypedWeakObjectPtrs<USoundWave>(InObjects);
MenuBuilder.AddMenuEntry(
LOCTEXT("SoundWave_CreateCue", "Create Cue"),
LOCTEXT("SoundWave_CreateCueTooltip", "Creates a sound cue using this sound wave."),
FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.SoundCue"),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_SoundWave::ExecuteCreateSoundCue, SoundNodes ),
FCanExecuteAction()
)
);
}
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();
}
void FSequencerObjectBindingNode::AddPropertyMenuItems(FMenuBuilder& AddTrackMenuBuilder, TArray<TArray<UProperty*> > KeyableProperties, int32 PropertyNameIndexStart, int32 PropertyNameIndexEnd)
{
TArray<PropertyMenuData> KeyablePropertyMenuData;
for (auto KeyableProperty : KeyableProperties)
{
TArray<FString> PropertyNames;
if (PropertyNameIndexEnd == -1)
{
PropertyNameIndexEnd = KeyableProperty.Num();
}
//@todo
if (PropertyNameIndexStart >= KeyableProperty.Num())
{
continue;
}
for (int32 PropertyNameIndex = PropertyNameIndexStart; PropertyNameIndex < PropertyNameIndexEnd; ++PropertyNameIndex)
{
PropertyNames.Add(KeyableProperty[PropertyNameIndex]->GetDisplayNameText().ToString());
}
PropertyMenuData KeyableMenuData;
{
KeyableMenuData.PropertyPath = KeyableProperty;
KeyableMenuData.MenuName = FString::Join( PropertyNames, TEXT( "." ) );
}
KeyablePropertyMenuData.Add(KeyableMenuData);
}
// Sort on the menu name
KeyablePropertyMenuData.Sort([](const PropertyMenuData& A, const PropertyMenuData& B)
{
int32 CompareResult = A.MenuName.Compare(B.MenuName);
return CompareResult < 0;
});
// Add menu items
for (int32 MenuDataIndex = 0; MenuDataIndex < KeyablePropertyMenuData.Num(); ++MenuDataIndex)
{
FUIAction AddTrackMenuAction(FExecuteAction::CreateSP(this, &FSequencerObjectBindingNode::HandlePropertyMenuItemExecute, KeyablePropertyMenuData[MenuDataIndex].PropertyPath));
AddTrackMenuBuilder.AddMenuEntry(FText::FromString(KeyablePropertyMenuData[MenuDataIndex].MenuName), FText(), FSlateIcon(), AddTrackMenuAction);
}
}
void FFaceFXAnimationTrackEditor::BuildObjectBindingTrackMenu(FMenuBuilder& MenuBuilder, const FGuid& ObjectBinding, const UClass* ObjectClass)
{
if (ObjectClass != UFaceFXComponent::StaticClass())
{
//only show widget on the component menu
return;
}
if (UFaceFXComponent* FaceFXComponent = GetFaceFXComponent(ObjectBinding))
{
MenuBuilder.AddMenuEntry(
LOCTEXT("SequencerAddSection", "Facial Animation"),
LOCTEXT("SequencerAddSectionTooltip", "Adds a FaceFX facial animation section"),
FSlateIcon(),
FUIAction(FExecuteAction::CreateRaw(this, &FFaceFXAnimationTrackEditor::OnAddKey, ObjectBinding)));
}
}
void FGameplayDebugger::CreateSettingSubMenu(FMenuBuilder& Builder)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
Builder.AddMenuEntry(
LOCTEXT("Test_GameplayDebugger_Menu", "Test Gameplay Debugger Option"),
LOCTEXT("Test_GameplayDebugger_Menu_Tooltip", "If Enabled, actors will snap to the nearest location on the constraint plane (NOTE: Only works correctly in perspective views right now!)"),
FSlateIcon(),
FUIAction(
FExecuteAction()/*FExecuteAction::CreateRaw(PlanarPolicy.Get(), &FPlanarConstraintSnapPolicy::ToggleEnabled)*/,
FCanExecuteAction(),
FIsActionChecked()/*FIsActionChecked::CreateRaw(PlanarPolicy.Get(), &FPlanarConstraintSnapPolicy::IsEnabled)*/
),
NAME_None,
EUserInterfaceActionType::Button,
NAME_None);
#endif
}
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();
}
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 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 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 FSlomoTrackEditor::BuildAddTrackMenu(FMenuBuilder& MenuBuilder)
{
UMovieSceneSequence* RootMovieSceneSequence = GetSequencer()->GetRootMovieSceneSequence();
if ((RootMovieSceneSequence == nullptr) || (RootMovieSceneSequence->GetClass()->GetName() != TEXT("LevelSequence")))
{
return;
}
MenuBuilder.AddMenuEntry(
LOCTEXT("AddPlayRateTrack", "Play Rate Track"),
LOCTEXT("AddPlayRateTrackTooltip", "Adds a new track that controls the playback rate of the sequence."),
FSlateIcon(FEditorStyle::GetStyleSetName(), "Sequencer.Tracks.Slomo"),
FUIAction(
FExecuteAction::CreateRaw(this, &FSlomoTrackEditor::HandleAddSlomoTrackMenuEntryExecute)
)
);
}
void FSpawnTrackEditor::BuildObjectBindingTrackMenu(FMenuBuilder& MenuBuilder, const FGuid& ObjectBinding, const UClass* ObjectClass)
{
UMovieSceneSequence* MovieSequence = GetSequencer()->GetFocusedMovieSceneSequence();
if (!MovieSequence || MovieSequence->GetClass()->GetName() != TEXT("LevelSequence") || !MovieSequence->GetMovieScene()->FindSpawnable(ObjectBinding))
{
return;
}
MenuBuilder.AddMenuEntry(
LOCTEXT("AddSpawnTrack", "Spawn Track"),
LOCTEXT("AddSpawnTrackTooltip", "Adds a new track that controls the lifetime of the track's spawnable object."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateRaw(this, &FSpawnTrackEditor::HandleAddSpawnTrackMenuEntryExecute, ObjectBinding),
FCanExecuteAction::CreateSP(this, &FSpawnTrackEditor::CanAddSpawnTrack, ObjectBinding)
)
);
}
void FCameraCutTrackEditor::BuildAddTrackMenu(FMenuBuilder& MenuBuilder)
{
UMovieSceneSequence* RootMovieSceneSequence = GetSequencer()->GetRootMovieSceneSequence();
if ((RootMovieSceneSequence == nullptr) || (RootMovieSceneSequence->GetClass()->GetName() != TEXT("LevelSequence")))
{
return;
}
MenuBuilder.AddMenuEntry(
LOCTEXT("AddCameraCutTrack", "Camera Cut Track"),
LOCTEXT("AddCameraCutTooltip", "Adds a camera cut track, as well as a new camera cut at the current scrubber location if a camera is selected."),
FSlateIcon(FEditorStyle::GetStyleSetName(), "Sequencer.Tracks.CameraCut"),
FUIAction(
FExecuteAction::CreateRaw(this, &FCameraCutTrackEditor::HandleAddCameraCutTrackMenuEntryExecute),
FCanExecuteAction::CreateRaw(this, &FCameraCutTrackEditor::HandleAddCameraCutTrackMenuEntryCanExecute)
)
);
}
void FAssetTypeActions_AnimationAsset::GetActions( const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder )
{
auto AnimAssets = GetTypedWeakObjectPtrs<UAnimationAsset>(InObjects);
MenuBuilder.AddMenuEntry(
LOCTEXT("AnimSequenceBase_FindSkeleton", "Find Skeleton"),
LOCTEXT("AnimSequenceBase_FindSkeletonTooltip", "Finds the skeleton for the selected assets in the content browser."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_AnimationAsset::ExecuteFindSkeleton, AnimAssets ),
FCanExecuteAction()
)
);
MenuBuilder.AddSubMenu(
LOCTEXT("RetargetAnimSubmenu", "Retarget Anim Assets"),
LOCTEXT("RetargetAnimSubmenu_ToolTip", "Opens the retarget anim assets menu"),
FNewMenuDelegate::CreateSP( this, &FAssetTypeActions_AnimationAsset::FillRetargetMenu, InObjects ) );
}
void FLevelEditorContextMenuImpl::FillEditMenu( class FMenuBuilder& MenuBuilder, LevelEditorMenuContext ContextType )
{
MenuBuilder.AddMenuEntry( FGenericCommands::Get().Cut );
MenuBuilder.AddMenuEntry( FGenericCommands::Get().Copy );
MenuBuilder.AddMenuEntry( FGenericCommands::Get().Paste );
if (ContextType == LevelEditorMenuContext::Viewport)
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().PasteHere );
}
MenuBuilder.AddMenuEntry( FGenericCommands::Get().Duplicate );
MenuBuilder.AddMenuEntry( FGenericCommands::Get().Delete );
MenuBuilder.AddMenuEntry( FGenericCommands::Get().Rename );
}
void FParticleTrackEditor::BuildTrackContextMenu( FMenuBuilder& MenuBuilder, UMovieSceneTrack* Track )
{
UInterpTrackToggle* MatineeToggleTrack = nullptr;
for ( UObject* CopyPasteObject : GUnrealEd->MatineeCopyPasteBuffer )
{
MatineeToggleTrack = Cast<UInterpTrackToggle>( CopyPasteObject );
if ( MatineeToggleTrack != nullptr )
{
break;
}
}
UMovieSceneParticleTrack* ParticleTrack = Cast<UMovieSceneParticleTrack>( Track );
MenuBuilder.AddMenuEntry(
NSLOCTEXT( "Sequencer", "PasteMatineeToggleTrack", "Paste Matinee Particle Track" ),
NSLOCTEXT( "Sequencer", "PasteMatineeToggleTrackTooltip", "Pastes keys from a Matinee particle track into this track." ),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateStatic( &FMatineeImportTools::CopyInterpParticleTrack, GetSequencer().ToSharedRef(), MatineeToggleTrack, ParticleTrack ),
FCanExecuteAction::CreateLambda( [=]()->bool { return MatineeToggleTrack != nullptr && MatineeToggleTrack->ToggleTrack.Num() > 0 && ParticleTrack != nullptr; } ) ) );
}
PRAGMA_ENABLE_OPTIMIZATION
//static_assert(sizeof(FProfilerActionManager) == 0, "Cannot contain any variables at this moment.");
/*-----------------------------------------------------------------------------
FProfilerMenuBuilder
-----------------------------------------------------------------------------*/
void FProfilerMenuBuilder::AddMenuEntry( FMenuBuilder& MenuBuilder, const TSharedPtr< FUICommandInfo >& FUICommandInfo, const FUIAction& UIAction )
{
MenuBuilder.AddMenuEntry
(
FUICommandInfo->GetLabel(),
FUICommandInfo->GetDescription(),
FUICommandInfo->GetIcon(),
UIAction,
NAME_None,
FUICommandInfo->GetUserInterfaceType()
);
}
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 SVisualLoggerFilters::CreateFiltersMenuCategoryForGraph(FMenuBuilder& MenuBuilder, FName GraphName) const
{
for (auto Iter(CachedDatasPerGraph[GraphName].CreateConstIterator()); Iter; ++Iter)
{
const FName& DataName = *Iter;
const FText& LabelText = FText::FromString(DataName.ToString());
MenuBuilder.AddMenuEntry(
LabelText,
FText::Format(LOCTEXT("FilterByTooltipPrefix", "Filter by {0}"), LabelText),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP(this, &SVisualLoggerFilters::FilterByTypeClicked, GraphName, DataName),
FCanExecuteAction(),
FIsActionChecked::CreateSP(this, &SVisualLoggerFilters::IsAssetTypeActionsInUse, GraphName, DataName),
FIsActionButtonVisible::CreateLambda([this, LabelText]()->bool{return this->GraphsSearchString.Len() == 0 || LabelText.ToString().Find(this->GraphsSearchString) != INDEX_NONE; })),
NAME_None,
EUserInterfaceActionType::ToggleButton
);
}
}
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();
}
}
}
void SVisualLoggerFilters::CreateFiltersMenuCategoryForGraph(FMenuBuilder& MenuBuilder, FName MenuCategory) const
{
auto FiltersFromGraph = GraphFilters[MenuCategory];
for (auto Iter = FiltersFromGraph.CreateIterator(); Iter; ++Iter)
{
FName Name = **Iter;
const FText& LabelText = FText::FromString(Name.ToString());
MenuBuilder.AddMenuEntry(
LabelText,
FText::Format(LOCTEXT("FilterByTooltipPrefix", "Filter by {0}"), LabelText),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP(this, &SVisualLoggerFilters::FilterByTypeClicked, MenuCategory, Name),
FCanExecuteAction(),
FIsActionChecked::CreateSP(this, &SVisualLoggerFilters::IsAssetTypeActionsInUse, MenuCategory, Name),
FIsActionButtonVisible::CreateLambda([this, LabelText]()->bool{return this->GraphsFilter.Len() == 0 || LabelText.ToString().Find(this->GraphsFilter) != INDEX_NONE; })),
NAME_None,
EUserInterfaceActionType::ToggleButton
);
}
}
void FLevelEditorContextMenuImpl::FillGroupMenu( class FMenuBuilder& MenuBuilder )
{
if( SelectionInfo.NumSelectedUngroupedActors > 1 )
{
// Only show this menu item if we have more than one actor.
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().GroupActors );
}
if( SelectionInfo.bHaveSelectedLockedGroup || SelectionInfo.bHaveSelectedUnlockedGroup )
{
const int32 NumActiveGroups = AGroupActor::NumActiveGroups(true);
// Regroup will clear any existing groups and create a new one from the selection
// Only allow regrouping if multiple groups are selected, or a group and ungrouped actors are selected
if( NumActiveGroups > 1 || (NumActiveGroups && SelectionInfo.NumSelectedUngroupedActors) )
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().RegroupActors );
}
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().UngroupActors );
if( SelectionInfo.bHaveSelectedUnlockedGroup )
{
// Only allow removal of loose actors or locked subgroups
if( !SelectionInfo.bHaveSelectedLockedGroup || ( SelectionInfo.bHaveSelectedLockedGroup && SelectionInfo.bHaveSelectedSubGroup ) )
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().RemoveActorsFromGroup );
}
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().LockGroup );
}
if( SelectionInfo.bHaveSelectedLockedGroup )
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().UnlockGroup );
}
// Only allow group adds if a single group is selected in addition to ungrouped actors
if( AGroupActor::NumActiveGroups(true, false) == 1 && SelectionInfo.NumSelectedUngroupedActors )
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().AddActorsToGroup );
}
}
}
void FMediaTextureActions::GetActions( const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder )
{
FAssetTypeActions_Base::GetActions(InObjects, MenuBuilder);
auto Textures = GetTypedWeakObjectPtrs<UTexture>(InObjects);
MenuBuilder.AddMenuEntry(
LOCTEXT("MediaTexture_CreateMaterial", "Create Material"),
LOCTEXT("MediaTexture_CreateMaterialTooltip", "Creates a new material using this texture."),
FSlateIcon( FEditorStyle::GetStyleSetName(), "ClassIcon.Material" ),
FUIAction(
FExecuteAction::CreateSP(this, &FMediaTextureActions::ExecuteCreateMaterial, Textures),
FCanExecuteAction()
)
);
/* MenuBuilder.AddMenuEntry(
LOCTEXT("MediaTexture_CreateSlateBrush", "Create Slate Brush"),
LOCTEXT("MediaTexture_CreateSlateBrushToolTip", "Creates a new slate brush using this texture."),
FSlateIcon( FEditorStyle::GetStyleSetName(), "ClassIcon.SlateBrushAsset" ),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_MediaTexture::ExecuteCreateSlateBrush, Textures ),
FCanExecuteAction()
)
);*/
/* @todo AssetTypeActions Implement FindMaterials using the asset registry.
if ( InObjects.Num() == 1 )
{
MenuBuilder.AddMenuEntry(
LOCTEXT("Texture_FindMaterials", "Find Materials Using This"),
LOCTEXT("Texture_FindMaterialsTooltip", "Finds all materials that use this material in the content browser."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_Texture::ExecuteFindMaterials, Textures(0) ),
FCanExecuteAction()
)
);
}*/
}
/** 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 FAnimationTrackEditor::BuildObjectBindingContextMenu(FMenuBuilder& MenuBuilder, const FGuid& ObjectBinding, const UClass* ObjectClass)
{
if (ObjectClass->IsChildOf(ASkeletalMeshActor::StaticClass()))
{
const TSharedPtr<ISequencer> ParentSequencer = GetSequencer();
USkeleton* Skeleton = AcquireSkeletonFromObjectGuid(ObjectBinding);
if (Skeleton)
{
// Load the asset registry module
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
// Collect a full list of assets with the specified class
TArray<FAssetData> AssetDataList;
AssetRegistryModule.Get().GetAssetsByClass(UAnimSequence::StaticClass()->GetFName(), AssetDataList);
for( int32 AssetIndex = 0; AssetIndex < AssetDataList.Num(); ++AssetIndex )
{
const FAssetData& PossibleAnimSequence = AssetDataList[AssetIndex];
if( FAssetData(Skeleton).GetExportTextName() == PossibleAnimSequence.TagsAndValues.FindRef("Skeleton") )
{
FFormatNamedArguments Args;
Args.Add( TEXT("AnimationName"), FText::FromName( PossibleAnimSequence.AssetName ) );
UAnimSequence* AnimSequence = CastChecked<UAnimSequence>(AssetDataList[AssetIndex].GetAsset());
MenuBuilder.AddMenuEntry(
FText::Format( NSLOCTEXT("Sequencer", "AddAnimSequence", "Add {AnimationName}"), Args ),
FText::Format( NSLOCTEXT("Sequencer", "AddAnimSequenceTooltip", "Adds a {AnimationName} animation to this skeletal mesh."), Args ),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(ParentSequencer.Get(), &ISequencer::AddAnimation, ObjectBinding, AnimSequence))
);
}
}
}
}
}
void FLevelCollectionModel::FillLockSubMenu(FMenuBuilder& InMenuBuilder)
{
const FLevelCollectionCommands& Commands = FLevelCollectionCommands::Get();
InMenuBuilder.AddMenuEntry( Commands.World_LockSelectedLevels );
InMenuBuilder.AddMenuEntry( Commands.World_UnockSelectedLevels );
InMenuBuilder.AddMenuEntry( Commands.World_LockAllLevels );
InMenuBuilder.AddMenuEntry( Commands.World_UnockAllLevels );
if (Editor->bLockReadOnlyLevels)
{
InMenuBuilder.AddMenuEntry( Commands.World_UnlockReadOnlyLevels );
}
else
{
InMenuBuilder.AddMenuEntry( Commands.World_LockReadOnlyLevels );
}
}
void FLevelEditorContextMenuImpl::FillPivotMenu( FMenuBuilder& MenuBuilder )
{
MenuBuilder.BeginSection("SaveResetPivot");
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().SavePivotToPrePivot );
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().ResetPrePivot );
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().ResetPivot );
}
MenuBuilder.EndSection();
MenuBuilder.BeginSection("MovePivot");
{
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().MovePivotHere );
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().MovePivotHereSnapped );
MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().MovePivotToCenter );
}
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 FAssetTypeActions_EditorUtilityBlueprint::GetActions(const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder)
{
auto Blueprints = GetTypedWeakObjectPtrs<UEditorUtilityBlueprint>(InObjects);
/*
if (Blueprints.Num() == 1)
{
if (UEditorUtilityBlueprint* Blueprint = Blueprints[0].Get())
{
if (Blueprint->ParentClass->IsChildOf(UGlobalEditorUtilityBase::StaticClass()))
{
MenuBuilder.AddMenuEntry(
LOCTEXT("BlutilityExecute", "Run Blutility"),
LOCTEXT("BlutilityExecute_Tooltip", "Run this blutility."),
NAME_None,
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_EditorUtilityBlueprint::ExecuteGlobalBlutility, Blueprints[0] ),
FCanExecuteAction()
)
);
}
}
}
*/
MenuBuilder.AddMenuEntry(
LOCTEXT("Blutility_Edit", "Edit Blueprint"),
LOCTEXT("Blutility_EditTooltip", "Opens the selected blueprints in the full blueprint editor."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_EditorUtilityBlueprint::ExecuteEdit, Blueprints ),
FCanExecuteAction()
)
);
MenuBuilder.AddMenuEntry(
LOCTEXT("Blutility_EditDefaults", "Edit Defaults"),
LOCTEXT("Blutility_EditDefaultsTooltip", "Edits the default properties for the selected blueprints."),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_EditorUtilityBlueprint::ExecuteEditDefaults, Blueprints ),
FCanExecuteAction()
)
);
if (Blueprints.Num() == 1)
{
TAttribute<FText>::FGetter DynamicTooltipGetter;
DynamicTooltipGetter.BindSP(this, &FAssetTypeActions_EditorUtilityBlueprint::GetNewDerivedBlueprintTooltip, Blueprints[0]);
TAttribute<FText> DynamicTooltipAttribute = TAttribute<FText>::Create(DynamicTooltipGetter);
MenuBuilder.AddMenuEntry(
LOCTEXT("Blutility_NewDerivedBlueprint", "Create Blueprint based on this"),
DynamicTooltipAttribute,
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &FAssetTypeActions_EditorUtilityBlueprint::ExecuteNewDerivedBlueprint, Blueprints[0] ),
FCanExecuteAction::CreateSP( this, &FAssetTypeActions_EditorUtilityBlueprint::CanExecuteNewDerivedBlueprint, Blueprints[0] )
)
);
}
}
