/** UI_COMMAND takes long for the compile to optimize */ PRAGMA_DISABLE_OPTIMIZATION void FLevelViewportCommands::RegisterCommands() { UI_COMMAND( ToggleMaximize, "Maximize Viewport", "Toggles the Maximize state of the current viewport", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ToggleGameView, "Game View", "Toggles game view. Game view shows the scene as it appears in game", EUserInterfaceActionType::ToggleButton, FInputChord( EKeys::G ) ); UI_COMMAND( ToggleImmersive, "Immersive Mode", "Switches this viewport between immersive mode and regular mode", EUserInterfaceActionType::ToggleButton, FInputChord( EKeys::F11 ) ); UI_COMMAND( CreateCamera, "Create Camera Here", "Creates a new camera actor at the current location of this viewport's camera", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HighResScreenshot, "High Resolution Screenshot...", "Opens the control panel for high resolution screenshots", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( UseDefaultShowFlags, "Use Defaults", "Resets all show flags to default", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( PilotSelectedActor, "Pilot Selected Actor", "Move the selected actor around using the viewport controls, and bind the viewport to the actor's location and orientation.", EUserInterfaceActionType::Button, FInputChord( EModifierKey::Control | EModifierKey::Shift, EKeys::P ) ); UI_COMMAND( EjectActorPilot, "Eject from Actor Pilot", "Stop piloting an actor with the current viewport. Unlocks the viewport's position and orientation from the actor the viewport is currently piloting.", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( ToggleActorPilotCameraView, "Actor Pilot Camera View", "Toggles showing the exact camera view when using the viewport to pilot a camera", EUserInterfaceActionType::ToggleButton, FInputChord( EModifierKey::Control | EModifierKey::Shift, EKeys::C ) ); UI_COMMAND( ViewportConfig_OnePane, "Layout One Pane", "Changes the viewport arrangement to one pane", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_TwoPanesH, "Layout Two Panes (horizontal)", "Changes the viewport arrangement to two panes, side-by-side", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_TwoPanesV, "Layout Two Panes (vertical)", "Changes the viewport arrangement to two panes, one above the other", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesLeft, "Layout Three Panes (one left, two right)", "Changes the viewport arrangement to three panes, one on the left, two on the right", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesRight, "Layout Three Panes (one right, two left)", "Changes the viewport arrangement to three panes, one on the right, two on the left", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesTop, "Layout Three Panes (one top, two bottom)", "Changes the viewport arrangement to three panes, one on the top, two on the bottom", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesBottom, "Layout Three Panes (one bottom, two top)", "Changes the viewport arrangement to three panes, one on the bottom, two on the top", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesLeft, "Layout Four Panes (one left, three right)", "Changes the viewport arrangement to four panes, one on the left, three on the right", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesRight, "Layout Four Panes (one right, three left)", "Changes the viewport arrangement to four panes, one on the right, three on the left", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesTop, "Layout Four Panes (one top, three bottom)", "Changes the viewport arrangement to four panes, one on the top, three on the bottom", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesBottom, "Layout Four Panes (one bottom, three top)", "Changes the viewport arrangement to four panes, one on the bottom, three on the top", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanes2x2, "Layout Four Panes (2x2)", "Changes the viewport arrangement to four panes, in a 2x2 grid", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ApplyMaterialToActor, "Apply Material", "Attempts to apply a dropped material to this object", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( ToggleCinematicPreview, "Toggles Cinematic Preview", "If enabled, allows Matinee or Sequencer previews to play in this viewport", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( FindInLevelScriptBlueprint, "Find In Level Script", "Finds references of a selected actor in the level script blueprint", EUserInterfaceActionType::Button, FInputChord(EModifierKey::Control, EKeys::K) ); UI_COMMAND( AdvancedSettings, "Advanced Settings...", "Opens the advanced viewport settings", EUserInterfaceActionType::Button, FInputChord()); // Generate a command for each buffer visualization mode { struct FMaterialIterator { const TSharedRef<class FBindingContext> Parent; FLevelViewportCommands::TBufferVisualizationModeCommandMap& CommandMap; FMaterialIterator(const TSharedRef<class FBindingContext> InParent, FLevelViewportCommands::TBufferVisualizationModeCommandMap& InCommandMap) : Parent(InParent) , CommandMap(InCommandMap) { } void ProcessValue(const FString& InMaterialName, const UMaterial* InMaterial, const FText& InDisplayName) { FName ViewportCommandName = *(FString(TEXT("BufferVisualizationMenu")) + InMaterialName); FBufferVisualizationRecord& Record = CommandMap.Add(ViewportCommandName, FBufferVisualizationRecord()); Record.Name = *InMaterialName; const FText MaterialNameText = FText::FromString( InMaterialName ); Record.Command = FUICommandInfoDecl( Parent, ViewportCommandName, MaterialNameText, MaterialNameText ) .UserInterfaceType( EUserInterfaceActionType::RadioButton ) .DefaultChord( FInputChord() ); } }; BufferVisualizationModeCommands.Empty(); FName ViewportCommandName = *(FString(TEXT("BufferVisualizationOverview"))); FBufferVisualizationRecord& OverviewRecord = BufferVisualizationModeCommands.Add(ViewportCommandName, FBufferVisualizationRecord()); OverviewRecord.Name = NAME_None; OverviewRecord.Command = FUICommandInfoDecl( this->AsShared(), ViewportCommandName, LOCTEXT("BufferVisualization", "Overview"), LOCTEXT("BufferVisualization", "Overview") ) .UserInterfaceType( EUserInterfaceActionType::RadioButton ) .DefaultChord( FInputChord() ); FMaterialIterator It(this->AsShared(), BufferVisualizationModeCommands); GetBufferVisualizationData().IterateOverAvailableMaterials(It); } const TArray<FShowFlagData>& ShowFlagData = GetShowFlagMenuItems(); // Generate a command for each show flag for( int32 ShowFlag = 0; ShowFlag < ShowFlagData.Num(); ++ShowFlag ) { const FShowFlagData& SFData = ShowFlagData[ShowFlag]; FFormatNamedArguments Args; Args.Add( TEXT("ShowFlagName"), SFData.DisplayName ); FText LocalizedName; switch( SFData.Group ) { case SFG_Visualize: LocalizedName = FText::Format( LOCTEXT("VisualizeFlagLabel", "Visualize {ShowFlagName}"), Args ); break; default: LocalizedName = FText::Format( LOCTEXT("ShowFlagLabel", "Show {ShowFlagName}"), Args ); break; } //@todo Slate: The show flags system does not support descriptions currently const FText ShowFlagDesc; TSharedPtr<FUICommandInfo> ShowFlagCommand = FUICommandInfoDecl( this->AsShared(), SFData.ShowFlagName, LocalizedName, ShowFlagDesc ) .UserInterfaceType( EUserInterfaceActionType::ToggleButton ) .DefaultChord( SFData.InputChord ) .Icon(SFData.Group == EShowFlagGroup::SFG_Normal ? FSlateIcon(FEditorStyle::GetStyleSetName(), FEditorStyle::Join( GetContextName(), TCHAR_TO_ANSI( *FString::Printf( TEXT(".%s"), *SFData.ShowFlagName.ToString() ) ) ) ) : FSlateIcon()); ShowFlagCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowFlagCommand, SFData.DisplayName ) ); } // Generate a command for each volume class { UI_COMMAND( ShowAllVolumes, "Show All Volumes", "Shows all volumes", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HideAllVolumes, "Hide All Volumes", "Hides all volumes", EUserInterfaceActionType::Button, FInputChord() ); TArray< UClass* > VolumeClasses; UUnrealEdEngine::GetSortedVolumeClasses(&VolumeClasses); for( int32 VolumeClassIndex = 0; VolumeClassIndex < VolumeClasses.Num(); ++VolumeClassIndex ) { //@todo Slate: The show flags system does not support descriptions currently const FText VolumeDesc; const FName VolumeName = VolumeClasses[VolumeClassIndex]->GetFName(); FText DisplayName; FEngineShowFlags::FindShowFlagDisplayName( VolumeName.ToString(), DisplayName ); FFormatNamedArguments Args; Args.Add( TEXT("ShowFlagName"), DisplayName ); const FText LocalizedName = FText::Format( LOCTEXT("ShowFlagLabel_Visualize", "Visualize {ShowFlagName}"), Args ); TSharedPtr<FUICommandInfo> ShowVolumeCommand = FUICommandInfoDecl( this->AsShared(), VolumeName, LocalizedName, VolumeDesc ) .UserInterfaceType( EUserInterfaceActionType::ToggleButton ); ShowVolumeCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowVolumeCommand, DisplayName ) ); } } // Generate a command for show/hide all layers { UI_COMMAND( ShowAllLayers, "Show All Layers", "Shows all layers", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HideAllLayers, "Hide All Layers", "Hides all layers", EUserInterfaceActionType::Button, FInputChord() ); } // Generate a command for each sprite category { UI_COMMAND( ShowAllSprites, "Show All Sprites", "Shows all sprites", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HideAllSprites, "Hide All Sprites", "Hides all sprites", EUserInterfaceActionType::Button, FInputChord() ); // get all the known layers // Get a fresh list as GUnrealEd->SortedSpriteInfo may not yet be built. TArray<FSpriteCategoryInfo> SortedSpriteInfo; UUnrealEdEngine::MakeSortedSpriteInfo(SortedSpriteInfo); FString SpritePrefix = TEXT("ShowSprite_"); for( int32 InfoIndex = 0; InfoIndex < SortedSpriteInfo.Num(); ++InfoIndex ) { const FSpriteCategoryInfo& SpriteInfo = SortedSpriteInfo[InfoIndex]; const FName CommandName = FName( *(SpritePrefix + SpriteInfo.Category.ToString()) ); FFormatNamedArguments Args; Args.Add( TEXT("SpriteName"), SpriteInfo.DisplayName ); const FText LocalizedName = FText::Format( NSLOCTEXT("UICommands", "SpriteShowFlagName", "Show {SpriteName} Sprites"), Args ); TSharedPtr<FUICommandInfo> ShowSpriteCommand = FUICommandInfoDecl( this->AsShared(), CommandName, LocalizedName, SpriteInfo.Description ) .UserInterfaceType( EUserInterfaceActionType::ToggleButton ); ShowSpriteCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowSpriteCommand, SpriteInfo.DisplayName ) ); } } // Generate a command for each Stat category { UI_COMMAND(HideAllStats, "Hide All Stats", "Hides all Stats", EUserInterfaceActionType::Button, FInputChord()); // Bind a listener here for any additional stat commands that get registered later. UEngine::NewStatDelegate.AddRaw(this, &FLevelViewportCommands::HandleNewStat); #if STATS FStatGroupGameThreadNotifier::Get().NewStatGroupDelegate.BindRaw(this, &FLevelViewportCommands::HandleNewStatGroup); #endif } // Map the bookmark index to default key. // If the max bookmark number ever increases the new bookmarks will not have default keys TArray< FKey > NumberKeyNames; NumberKeyNames.Add( EKeys::Zero ); NumberKeyNames.Add( EKeys::One ); NumberKeyNames.Add( EKeys::Two ); NumberKeyNames.Add( EKeys::Three ); NumberKeyNames.Add( EKeys::Four ); NumberKeyNames.Add( EKeys::Five ); NumberKeyNames.Add( EKeys::Six ); NumberKeyNames.Add( EKeys::Seven ); NumberKeyNames.Add( EKeys::Eight ); NumberKeyNames.Add( EKeys::Nine ); for( int32 BookmarkIndex = 0; BookmarkIndex < AWorldSettings::MAX_BOOKMARK_NUMBER; ++BookmarkIndex ) { TSharedRef< FUICommandInfo > JumpToBookmark = FUICommandInfoDecl( this->AsShared(), //Command class FName( *FString::Printf( TEXT( "JumpToBookmark%i" ), BookmarkIndex ) ), //CommandName FText::Format( NSLOCTEXT("LevelEditorCommands", "JumpToBookmark", "Jump to Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label FText::Format( NSLOCTEXT("LevelEditorCommands", "JumpToBookmark_ToolTip", "Moves the viewport to the location and orientation stored at bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip .UserInterfaceType( EUserInterfaceActionType::Button ) //interface type .DefaultChord( FInputChord( NumberKeyNames.IsValidIndex( BookmarkIndex ) ? NumberKeyNames[BookmarkIndex] : EKeys::Invalid ) ); //default chord JumpToBookmarkCommands.Add( JumpToBookmark ); TSharedRef< FUICommandInfo > SetBookmark = FUICommandInfoDecl( this->AsShared(), //Command class FName( *FString::Printf( TEXT( "SetBookmark%i" ), BookmarkIndex ) ), //CommandName FText::Format( NSLOCTEXT("LevelEditorCommands", "SetBookmark", "Set Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label FText::Format( NSLOCTEXT("LevelEditorCommands", "SetBookmark_ToolTip", "Stores the viewports location and orientation in bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip .UserInterfaceType( EUserInterfaceActionType::Button ) //interface type .DefaultChord( FInputChord( EModifierKey::Control, NumberKeyNames.IsValidIndex( BookmarkIndex ) ? NumberKeyNames[BookmarkIndex] : EKeys::Invalid ) ); //default chord SetBookmarkCommands.Add( SetBookmark ); TSharedRef< FUICommandInfo > ClearBookMark = FUICommandInfoDecl( this->AsShared(), //Command class FName( *FString::Printf( TEXT( "ClearBookmark%i" ), BookmarkIndex ) ), //CommandName FText::Format( NSLOCTEXT("LevelEditorCommands", "ClearBookmark", "Clear Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label FText::Format( NSLOCTEXT("LevelEditorCommands", "ClearBookmark_ToolTip", "Clears the viewports location and orientation in bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip .UserInterfaceType( EUserInterfaceActionType::Button ) //interface type .DefaultChord( FInputChord() ); //default chord ClearBookmarkCommands.Add( ClearBookMark ); } UI_COMMAND( ClearAllBookMarks, "Clear All Bookmarks", "Clears all the bookmarks", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( EnablePreviewMesh, "Hold To Enable Preview Mesh", "When held down a preview mesh appears under the cursor", EUserInterfaceActionType::Button, FInputChord(EKeys::Backslash) ); UI_COMMAND( CyclePreviewMesh, "Cycles Preview Mesh", "Cycles available preview meshes", EUserInterfaceActionType::Button, FInputChord( EModifierKey::Shift, EKeys::Backslash ) ); }
void SScrubWidget::CreateContextMenu(float CurrentFrameTime, const FPointerEvent& MouseEvent) { if ((OnCropAnimSequence.IsBound() || OnReZeroAnimSequence.IsBound() || OnAddAnimSequence.IsBound()) && (SequenceLength.Get() >= MINIMUM_ANIMATION_LENGTH)) { const bool CloseAfterSelection = true; FMenuBuilder MenuBuilder( CloseAfterSelection, NULL ); MenuBuilder.BeginSection("SequenceEditingContext", LOCTEXT("SequenceEditing", "Sequence Editing") ); { float CurrentFrameFraction = CurrentFrameTime / SequenceLength.Get(); int32 CurrentFrameNumber = CurrentFrameFraction * NumOfKeys.Get(); FUIAction Action; FText Label; if (OnCropAnimSequence.IsBound()) { //Menu - "Remove Before" //Only show this option if the selected frame is greater than frame 1 (first frame) if (CurrentFrameNumber > 0) { CurrentFrameFraction = float(CurrentFrameNumber) / (float)NumOfKeys.Get(); //Corrected frame time based on selected frame number float CorrectedFrameTime = CurrentFrameFraction * SequenceLength.Get(); Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnSequenceCroppedCalled, true, CorrectedFrameTime)); Label = FText::Format(LOCTEXT("RemoveTillFrame", "Remove frame 0 to frame {0}"), FText::AsNumber(CurrentFrameNumber)); MenuBuilder.AddMenuEntry(Label, LOCTEXT("RemoveBefore_ToolTip", "Remove sequence before current position"), FSlateIcon(), Action); } uint32 NextFrameNumber = CurrentFrameNumber + 1; //Menu - "Remove After" //Only show this option if next frame (CurrentFrameNumber + 1) is valid if (NextFrameNumber < NumOfKeys.Get()) { float NextFrameFraction = float(NextFrameNumber) / (float)NumOfKeys.Get(); float NextFrameTime = NextFrameFraction * SequenceLength.Get(); Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnSequenceCroppedCalled, false, NextFrameTime)); Label = FText::Format(LOCTEXT("RemoveFromFrame", "Remove from frame {0} to frame {1}"), FText::AsNumber(NextFrameNumber), FText::AsNumber(NumOfKeys.Get())); MenuBuilder.AddMenuEntry(Label, LOCTEXT("RemoveAfter_ToolTip", "Remove sequence after current position"), FSlateIcon(), Action); } } if (OnAddAnimSequence.IsBound()) { MenuBuilder.AddMenuSeparator(); //Corrected frame time based on selected frame number float CorrectedFrameTime = CurrentFrameFraction * SequenceLength.Get(); Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnSequenceAddedCalled, true, CurrentFrameNumber)); Label = FText::Format(LOCTEXT("InsertBeforeCurrentFrame", "Insert frame before {0}"), FText::AsNumber(CurrentFrameNumber)); MenuBuilder.AddMenuEntry(Label, LOCTEXT("InsertBefore_ToolTip", "Insert a frame before current position"), FSlateIcon(), Action); Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnSequenceAddedCalled, false, CurrentFrameNumber)); Label = FText::Format(LOCTEXT("InsertAfterCurrentFrame", "Insert frame after {0}"), FText::AsNumber(CurrentFrameNumber)); MenuBuilder.AddMenuEntry(Label, LOCTEXT("InsertAfter_ToolTip", "Insert a frame after current position"), FSlateIcon(), Action); } if(OnAppendAnimSequence.IsBound()) { MenuBuilder.AddMenuSeparator(); //Corrected frame time based on selected frame number Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnShowPopupOfAppendAnimation, true)); MenuBuilder.AddMenuEntry(LOCTEXT("AppendBegin", "Append in the beginning"), LOCTEXT("AppendBegin_ToolTip", "Append in the beginning"), FSlateIcon(), Action); Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnShowPopupOfAppendAnimation, false)); MenuBuilder.AddMenuEntry(LOCTEXT("AppendEnd", "Append at the end"), LOCTEXT("AppendEnd_ToolTip", "Append at the end"), FSlateIcon(), Action); } if (OnReZeroAnimSequence.IsBound()) { MenuBuilder.AddMenuSeparator(); //Menu - "ReZero" Action = FUIAction(FExecuteAction::CreateSP(this, &SScrubWidget::OnReZeroCalled)); Label = FText::Format(LOCTEXT("ReZeroAtFrame", "ReZero at frame {0}"), FText::AsNumber(CurrentFrameNumber)); MenuBuilder.AddMenuEntry(Label, LOCTEXT("ReZeroAtFrame_ToolTip", "Resets the root track of the frame to (0, 0, 0), and apply the difference to all root transform of the sequence. It moves whole sequence to the amount of current root transform. "), FSlateIcon(), Action); } } MenuBuilder.EndSection(); FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath(); FSlateApplication::Get().PushMenu(SharedThis(this), WidgetPath, MenuBuilder.MakeWidget(), FSlateApplication::Get().GetCursorPos(), FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu)); } }
void FMainMenu::FillWindowMenu( FMenuBuilder& MenuBuilder, const TSharedRef< FExtender > Extender, const TSharedPtr<FTabManager> TabManager ) { // Automatically populate tab spawners from TabManager if (TabManager.IsValid()) { // Local editor tabs TabManager->PopulateLocalTabSpawnerMenu(MenuBuilder); // General tabs const IWorkspaceMenuStructure& MenuStructure = WorkspaceMenu::GetMenuStructure(); TabManager->PopulateTabSpawnerMenu(MenuBuilder, MenuStructure.GetStructureRoot()); } MenuBuilder.BeginSection("WindowGlobalTabSpawners"); { MenuBuilder.AddMenuEntry( LOCTEXT("ProjectLauncherLabel", "Project Launcher"), LOCTEXT("ProjectLauncherToolTip", "The Project Launcher provides advanced workflows for packaging, deploying and launching your projects."), FSlateIcon(FEditorStyle::GetStyleSetName(), "Launcher.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FMainMenu::OpenProjectLauncher)) ); //@todo The tab system needs to be able to be extendable by plugins [9/3/2013 Justin.Sargent] if (IModularFeatures::Get().IsModularFeatureAvailable(EditorFeatures::PluginsEditor)) { FGlobalTabmanager::Get()->PopulateTabSpawnerMenu(MenuBuilder, "PluginsEditor"); } } MenuBuilder.EndSection(); { // This is a temporary home for the spawners of experimental features that must be explicitly enabled. // When the feature becomes permanent and need not check a flag, register a nomad spawner for it in the proper WorkspaceMenu category bool bMessagingDebugger = GetDefault<UEditorExperimentalSettings>()->bMessagingDebugger; bool bBlutility = GetDefault<UEditorExperimentalSettings>()->bEnableEditorUtilityBlueprints; bool bLocalizationDashboard = GetDefault<UEditorExperimentalSettings>()->bEnableLocalizationDashboard; bool bTranslationPicker = GetDefault<UEditorExperimentalSettings>()->bEnableTranslationPicker; bool bMergeActors = GetDefault<UEditorExperimentalSettings>()->bActorMerging; // Make sure at least one is enabled before creating the section if (bMessagingDebugger || bBlutility || bLocalizationDashboard || bTranslationPicker || bMergeActors) { MenuBuilder.BeginSection("ExperimentalTabSpawners", LOCTEXT("ExperimentalTabSpawnersHeading", "Experimental")); { // Messaging Debugger if (bMessagingDebugger) { MenuBuilder.AddMenuEntry( LOCTEXT("MessagingDebuggerLabel", "Messaging Debugger"), LOCTEXT("MessagingDebuggerToolTip", "The Messaging Debugger provides a visual utility for debugging the messaging system."), FSlateIcon(), // Icon lives in the plugin dir for the debugger FUIAction(FExecuteAction::CreateStatic(&FMainMenu::OpenMessagingDebugger)) ); } // Blutility if (bBlutility) { MenuBuilder.AddMenuEntry( LOCTEXT("BlutilityShelfLabel", "Blutility Shelf"), LOCTEXT("BlutilityShelfToolTip", "Open the blutility shelf."), FSlateIcon(), FUIAction(FExecuteAction::CreateStatic(&FMainMenu::OpenBlutilityShelf)) ); } // Localization Dashboard if (bLocalizationDashboard) { MenuBuilder.AddMenuEntry( LOCTEXT("LocalizationDashboardLabel", "Localization Dashboard"), LOCTEXT("BlutilityShelfToolTip", "Open the Localization Dashboard for this Project."), FSlateIcon(), FUIAction(FExecuteAction::CreateStatic(&FMainMenu::OpenLocalizationDashboard)) ); } // Translation Picker if (bTranslationPicker) { MenuBuilder.AddMenuEntry( LOCTEXT("TranslationPickerMenuItem", "Translation Picker"), LOCTEXT("TranslationPickerMenuItemToolTip", "Launch the Translation Picker to Modify Editor Translations"), FSlateIcon(), FUIAction(FExecuteAction::CreateStatic(&FMainFrameTranslationEditorMenu::HandleOpenTranslationPicker)) ); } // Actor merging if (bMergeActors) { MenuBuilder.AddMenuEntry( LOCTEXT("MergeActorsMenuLabel", "Merge Actors"), LOCTEXT("MergeActorsToolTip", "The Merge Actors tab provides tools for merging multiple actor meshes into a single mesh."), FSlateIcon(), FUIAction(FExecuteAction::CreateStatic(&FMainMenu::OpenMergeActors)) ); } } MenuBuilder.EndSection(); } } MenuBuilder.BeginSection("WindowLayout", NSLOCTEXT("MainAppMenu", "LayoutManagementHeader", "Layout")); { MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().ResetLayout); MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().SaveLayout); MenuBuilder.AddMenuEntry(FMainFrameCommands::Get().ToggleFullscreen); } MenuBuilder.EndSection(); }
TSharedRef<SWidget> FMaterialTrackEditor::OnGetAddParameterMenuContent( FGuid ObjectBinding, UMovieSceneMaterialTrack* MaterialTrack ) { FMenuBuilder AddParameterMenuBuilder( true, nullptr ); UMaterial* Material = GetMaterialForTrack( ObjectBinding, MaterialTrack ); if ( Material != nullptr ) { TArray<FParameterNameAndAction> ParameterNamesAndActions; // Collect scalar parameters. TArray<FName> ScalarParameterNames; TArray<FGuid> ScalarParmeterGuids; Material->GetAllScalarParameterNames( ScalarParameterNames, ScalarParmeterGuids ); for ( const FName& ScalarParameterName : ScalarParameterNames ) { FUIAction AddParameterMenuAction( FExecuteAction::CreateSP( this, &FMaterialTrackEditor::AddScalarParameter, ObjectBinding, MaterialTrack, ScalarParameterName ) ); FParameterNameAndAction NameAndAction( ScalarParameterName, AddParameterMenuAction ); ParameterNamesAndActions.Add(NameAndAction); } // Collect vector parameters. TArray<FName> VectorParameterNames; TArray<FGuid> VectorParmeterGuids; Material->GetAllVectorParameterNames( VectorParameterNames, VectorParmeterGuids ); for ( const FName& VectorParameterName : VectorParameterNames ) { FUIAction AddParameterMenuAction( FExecuteAction::CreateSP( this, &FMaterialTrackEditor::AddVectorParameter, ObjectBinding, MaterialTrack, VectorParameterName ) ); FParameterNameAndAction NameAndAction( VectorParameterName, AddParameterMenuAction ); ParameterNamesAndActions.Add( NameAndAction ); } // Sort and generate menu. ParameterNamesAndActions.Sort(); for ( FParameterNameAndAction NameAndAction : ParameterNamesAndActions ) { AddParameterMenuBuilder.AddMenuEntry( FText::FromName( NameAndAction.ParameterName ), FText(), FSlateIcon(), NameAndAction.Action ); } } return AddParameterMenuBuilder.MakeWidget(); }
void SMessagingDebugger::Construct( const FArguments& InArgs, const TSharedRef<SDockTab>& ConstructUnderMajorTab, const TSharedPtr<SWindow>& ConstructUnderWindow, const TSharedRef<IMessageTracer, ESPMode::ThreadSafe>& InMessageTracer, const TSharedRef<ISlateStyle>& InStyle ) { MessageTracer = InMessageTracer; Style = InStyle; // bind commands FUICommandList& ActionList = *CommandList; { const FMessagingDebuggerCommands& Commands = FMessagingDebuggerCommands::Get(); ActionList.MapAction(Commands.BreakDebugger, FExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleBreakDebuggerCommandExecute), FCanExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleBreakDebuggerCommandCanExecute)); ActionList.MapAction(Commands.ClearHistory, FExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleClearHistoryCommandExecute), FCanExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleClearHistoryCommandCanExecute)); ActionList.MapAction(Commands.ContinueDebugger, FExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleContinueDebuggerCommandExecute), FCanExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleContinueDebuggerCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SMessagingDebugger::HandleContinueDebuggerCommandIsVisible)); ActionList.MapAction(Commands.StartDebugger, FExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleStartDebuggerCommandExecute), FCanExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleStartDebuggerCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SMessagingDebugger::HandleStartDebuggerCommandIsVisible)); ActionList.MapAction(Commands.StepDebugger, FExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleStepDebuggerCommandExecute), FCanExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleStepDebuggerCommandCanExecute)); ActionList.MapAction(Commands.StopDebugger, FExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleStopDebuggerCommandExecute), FCanExecuteAction::CreateRaw(this, &SMessagingDebugger::HandleStopDebuggerCommandCanExecute)); } // create & initialize tab manager TabManager = FGlobalTabmanager::Get()->NewTabManager(ConstructUnderMajorTab); { TSharedRef<FWorkspaceItem> AppMenuGroup = TabManager->AddLocalWorkspaceMenuCategory(LOCTEXT("MessagingDebuggerGroupName", "Messaging Debugger")); TabManager->RegisterTabSpawner(BreakpointsTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, BreakpointsTabId)) .SetDisplayName(LOCTEXT("BreakpointsTabTitle", "Breakpoints")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "BreakpointsTabIcon")); TabManager->RegisterTabSpawner(EndpointDetailsTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, EndpointDetailsTabId)) .SetDisplayName(LOCTEXT("EndpointDetailsTabTitle", "Endpoint Details")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "EndpointDetailsTabIcon")); TabManager->RegisterTabSpawner(EndpointsTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, EndpointsTabId)) .SetDisplayName(LOCTEXT("EndpointsTabTitle", "Endpoints")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "EndpointsTabIcon")); TabManager->RegisterTabSpawner(InteractionGraphTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, InteractionGraphTabId)) .SetDisplayName(LOCTEXT("InteractionGraphTabTitle", "Interaction Graph")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "InteractionGraphTabIcon")); TabManager->RegisterTabSpawner(InterceptorsTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, InterceptorsTabId)) .SetDisplayName(LOCTEXT("InterceptorsTabTitle", "Interceptors")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "InterceptorsTabIcon")); TabManager->RegisterTabSpawner(MessageDataTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, MessageDataTabId)) .SetDisplayName(LOCTEXT("MessageDataTabTitle", "Message Data")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "MessageDataTabIcon")); TabManager->RegisterTabSpawner(MessageDetailsTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, MessageDetailsTabId)) .SetDisplayName(LOCTEXT("MessageDetailsTabTitle", "Message Details")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "MessageDetailsTabIcon")); TabManager->RegisterTabSpawner(MessageHistoryTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, MessageHistoryTabId)) .SetDisplayName(LOCTEXT("MessageHistoryTabTitle", "Message History")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "MessageHistoryTabIcon")); TabManager->RegisterTabSpawner(MessageTypesTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, MessageTypesTabId)) .SetDisplayName(LOCTEXT("MessageTypesTabTitle", "Message Types")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "MessageTypesTabIcon")); TabManager->RegisterTabSpawner(ToolbarTabId, FOnSpawnTab::CreateRaw(this, &SMessagingDebugger::HandleTabManagerSpawnTab, ToolbarTabId)) .SetDisplayName(LOCTEXT("ToolbarTabTitle", "Toolbar")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(Style->GetStyleSetName(), "ToolbarTabIcon")); } // create tab layout const TSharedRef<FTabManager::FLayout> Layout = FTabManager::NewLayout("MessagingDebuggerLayout_v1.0") ->AddArea ( FTabManager::NewPrimaryArea() ->SetOrientation(Orient_Horizontal) ->Split ( // left column FTabManager::NewSplitter() ->SetOrientation(Orient_Vertical) ->SetSizeCoefficient(0.25f) ->Split ( FTabManager::NewStack() ->AddTab(EndpointsTabId, ETabState::OpenedTab) ->SetSizeCoefficient(0.5f) ) ->Split ( FTabManager::NewStack() ->AddTab(EndpointDetailsTabId, ETabState::OpenedTab) ->AddTab(InterceptorsTabId, ETabState::OpenedTab) ->SetForegroundTab(EndpointDetailsTabId) ->SetSizeCoefficient(0.5f) ) ) ->Split ( // center column FTabManager::NewSplitter() ->SetOrientation(Orient_Vertical) ->SetSizeCoefficient(0.5f) ->Split ( FTabManager::NewStack() ->AddTab(ToolbarTabId, ETabState::OpenedTab) ->SetHideTabWell(true) )/* ->Split ( FTabManager::NewStack() ->AddTab(InteractionGraphTabName, ETabState::OpenedTab) ->SetHideTabWell(true) )*/ ->Split ( FTabManager::NewStack() ->AddTab(MessageHistoryTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ->SetSizeCoefficient(0.725f) ) ->Split ( FTabManager::NewStack() ->AddTab(BreakpointsTabId, ETabState::OpenedTab) ->AddTab(MessageDetailsTabId, ETabState::OpenedTab) ->SetSizeCoefficient(0.275f) ) ) ->Split ( // right column FTabManager::NewSplitter() ->SetOrientation(Orient_Vertical) ->SetSizeCoefficient(0.25f) ->Split ( FTabManager::NewStack() ->AddTab(MessageTypesTabId, ETabState::OpenedTab) ->SetSizeCoefficient(0.5f) ) ->Split ( FTabManager::NewStack() ->AddTab(MessageDataTabId, ETabState::OpenedTab) ->SetForegroundTab(MessageDetailsTabId) ->SetSizeCoefficient(0.5f) ) ) ); // create & initialize main menu FMenuBarBuilder MenuBarBuilder = FMenuBarBuilder(TSharedPtr<FUICommandList>()); MenuBarBuilder.AddPullDownMenu( LOCTEXT("WindowMenuLabel", "Window"), FText::GetEmpty(), FNewMenuDelegate::CreateStatic(&SMessagingDebugger::FillWindowMenu, TabManager), "Window" ); ChildSlot [ SNew(SVerticalBox) + SVerticalBox::Slot() .AutoHeight() [ MenuBarBuilder.MakeWidget() ] + SVerticalBox::Slot() .FillHeight(1.0f) [ TabManager->RestoreFrom(Layout, ConstructUnderWindow).ToSharedRef() ] ]; ConstructUnderMajorTab->SetOnPersistVisualState(SDockTab::FOnPersistVisualState::CreateRaw(this, &SMessagingDebugger::HandleMajorTabPersistVisualState)); }
TSharedPtr<SWidget> SMediaPlayerEditorMedia::HandleAssetPickerGetAssetContextMenu(const TArray<FAssetData>& SelectedAssets) { if (SelectedAssets.Num() <= 0) { return nullptr; } UObject* SelectedAsset = SelectedAssets[0].GetAsset(); if (SelectedAsset == nullptr) { return nullptr; } FMenuBuilder MenuBuilder(true /*bInShouldCloseWindowAfterMenuSelection=*/, nullptr); { // media section MenuBuilder.BeginSection("MediaSection", LOCTEXT("MediaSection", "Media")); { MenuBuilder.AddMenuEntry( LOCTEXT("EditMenuAction", "Edit..."), LOCTEXT("EditMenuActionTooltip", "Opens the selected asset for edit."), FSlateIcon(FEditorStyle::GetStyleSetName(), "ContentBrowser.AssetActions.Edit"), FUIAction( FExecuteAction::CreateLambda([=]() { FAssetEditorManager::Get().OpenEditorForAsset(SelectedAsset); }) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("LoadMenuAction", "Open"), LOCTEXT("LoadMenuActionTooltip", "Open this media asset in the player"), FSlateIcon(Style->GetStyleSetName(), "MediaPlayerEditor.NextMedia.Small"), FUIAction( FExecuteAction::CreateLambda([=]() { OpenMediaAsset(SelectedAsset); }) ) ); } MenuBuilder.EndSection(); // asset section MenuBuilder.BeginSection("AssetSection", LOCTEXT("AssetSection", "Asset")); { MenuBuilder.AddMenuEntry( LOCTEXT("FindInCbMenuAction", "Find in Content Browser"), LOCTEXT("FindInCbMenuActionTooltip", "Summons the Content Browser and navigates to the selected asset"), FSlateIcon(FEditorStyle::GetStyleSetName(), "SystemWideCommands.FindInContentBrowser"), FUIAction( FExecuteAction::CreateLambda([=]() { TArray<UObject*> AssetsToSync = TArrayBuilder<UObject*>().Add(SelectedAsset); GEditor->SyncBrowserToObjects(AssetsToSync); }) ) ); auto FileMediaSource = Cast<UFileMediaSource>(SelectedAsset); if (FileMediaSource != nullptr) { FFormatNamedArguments Args; { Args.Add(TEXT("FileManagerName"), FPlatformMisc::GetFileManagerName()); } MenuBuilder.AddMenuEntry( FText::Format(LOCTEXT("OpenInFileManager", "Show Media File in {FileManagerName}"), Args), LOCTEXT("OpenInFileManagerTooltip", "Finds the media file that this asset points to on disk"), FSlateIcon(FEditorStyle::GetStyleSetName(), "SystemWideCommands.FindInContentBrowser"), FUIAction( FExecuteAction::CreateLambda([=]() { FPlatformProcess::ExploreFolder(*FileMediaSource->GetFilePath()); }), FCanExecuteAction::CreateLambda([=]() -> bool { return FileMediaSource->Validate(); }) ) ); } } MenuBuilder.EndSection(); } return MenuBuilder.MakeWidget(); }
void FGuidStructCustomization::CustomizeStructHeader( TSharedRef<class IPropertyHandle> StructPropertyHandle, class FDetailWidgetRow& HeaderRow, IStructCustomizationUtils& StructCustomizationUtils ) { PropertyHandle = StructPropertyHandle; InputValid = true; // create quick-set menu FMenuBuilder QuickSetMenuBuilder(true, NULL); { FUIAction GenerateAction(FExecuteAction::CreateSP(this, &FGuidStructCustomization::HandleGuidActionClicked, EPropertyEditorGuidActions::Generate)); QuickSetMenuBuilder.AddMenuEntry(LOCTEXT("GenerateAction", "Generate"), LOCTEXT("GenerateActionHint", "Generate a new random globally unique identifier (GUID)."), FSlateIcon(), GenerateAction); FUIAction InvalidateAction(FExecuteAction::CreateSP(this, &FGuidStructCustomization::HandleGuidActionClicked, EPropertyEditorGuidActions::Invalidate)); QuickSetMenuBuilder.AddMenuEntry(LOCTEXT("InvalidateAction", "Invalidate"), LOCTEXT("InvalidateActionHint", "Set an invalid globally unique identifier (GUID)."), FSlateIcon(), InvalidateAction); } // create struct header HeaderRow.NameContent() [ StructPropertyHandle->CreatePropertyNameWidget() ] .ValueContent() .MinDesiredWidth(325.0f) .MaxDesiredWidth(325.0f) [ SNew(SHorizontalBox) + SHorizontalBox::Slot() .FillWidth(1.0f) [ // text box SAssignNew(TextBox, SEditableTextBox) .ClearKeyboardFocusOnCommit(false) .ForegroundColor(this, &FGuidStructCustomization::HandleTextBoxForegroundColor) .OnTextChanged(this, &FGuidStructCustomization::HandleTextBoxTextChanged) .OnTextCommitted(this, &FGuidStructCustomization::HandleTextBoxTextCommited) .SelectAllTextOnCommit(true) .Text(this, &FGuidStructCustomization::HandleTextBoxText) ] + SHorizontalBox::Slot() .AutoWidth() [ // quick-set menu SNew(SComboButton) .ContentPadding(FMargin(6.0, 2.0)) .MenuContent() [ QuickSetMenuBuilder.MakeWidget() ] ] ]; }
void FMainMenu::FillEditMenu( FMenuBuilder& MenuBuilder, const TSharedRef< FExtender > Extender, const TSharedPtr<FTabManager> TabManager ) { MenuBuilder.BeginSection("EditHistory", LOCTEXT("HistoryHeading", "History")); { struct Local { /** @return Returns a dynamic text string for Undo that contains the name of the action */ static FText GetUndoLabelText() { return FText::Format(LOCTEXT("DynamicUndoLabel", "Undo {0}"), GUnrealEd->Trans->GetUndoContext().Title); } /** @return Returns a dynamic text string for Redo that contains the name of the action */ static FText GetRedoLabelText() { return FText::Format(LOCTEXT("DynamicRedoLabel", "Redo {0}"), GUnrealEd->Trans->GetRedoContext().Title); } }; // Undo TAttribute<FText> DynamicUndoLabel; DynamicUndoLabel.BindStatic(&Local::GetUndoLabelText); MenuBuilder.AddMenuEntry( FGenericCommands::Get().Undo, "Undo", DynamicUndoLabel); // TAttribute< FString >::Create( &Local::GetUndoLabelText ) ); // Redo TAttribute< FText > DynamicRedoLabel; DynamicRedoLabel.BindStatic( &Local::GetRedoLabelText ); MenuBuilder.AddMenuEntry(FGenericCommands::Get().Redo, "Redo", DynamicRedoLabel); // TAttribute< FString >::Create( &Local::GetRedoLabelText ) ); // Show undo history MenuBuilder.AddMenuEntry( LOCTEXT("UndoHistoryTabTitle", "Undo History"), LOCTEXT("UndoHistoryTooltipText", "View the entire undo history."), FSlateIcon(FEditorStyle::GetStyleSetName(), "UndoHistory.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FUndoHistoryModule::ExecuteOpenUndoHistory)) ); } MenuBuilder.EndSection(); MenuBuilder.BeginSection("EditLocalTabSpawners", LOCTEXT("ConfigurationHeading", "Configuration")); { if (GetDefault<UEditorExperimentalSettings>()->bToolbarCustomization) { FUIAction ToggleMultiBoxEditMode( FExecuteAction::CreateStatic(&FMultiBoxSettings::ToggleToolbarEditing), FCanExecuteAction(), FIsActionChecked::CreateStatic(&FMultiBoxSettings::IsInToolbarEditMode) ); MenuBuilder.AddMenuEntry( LOCTEXT("EditToolbarsLabel", "Edit Toolbars"), LOCTEXT("EditToolbarsToolTip", "Allows customization of each toolbar"), FSlateIcon(), ToggleMultiBoxEditMode, NAME_None, EUserInterfaceActionType::ToggleButton ); // Automatically populate tab spawners from TabManager if (TabManager.IsValid()) { const IWorkspaceMenuStructure& MenuStructure = WorkspaceMenu::GetMenuStructure(); TabManager->PopulateTabSpawnerMenu(MenuBuilder, MenuStructure.GetEditOptions()); } } if (GetDefault<UEditorStyleSettings>()->bExpandConfigurationMenus) { MenuBuilder.AddSubMenu( LOCTEXT("EditorPreferencesSubMenuLabel", "Editor Preferences"), LOCTEXT("EditorPreferencesSubMenuToolTip", "Configure the behavior and features of this Editor"), FNewMenuDelegate::CreateStatic(&FSettingsMenu::MakeMenu, FName("Editor")), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "EditorPreferences.TabIcon") ); MenuBuilder.AddSubMenu( LOCTEXT("ProjectSettingsSubMenuLabel", "Project Settings"), LOCTEXT("ProjectSettingsSubMenuToolTip", "Change the settings of the currently loaded project"), FNewMenuDelegate::CreateStatic(&FSettingsMenu::MakeMenu, FName("Project")), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "ProjectSettings.TabIcon") ); } else { #if !PLATFORM_MAC // Handled by app's menu in menu bar MenuBuilder.AddMenuEntry( LOCTEXT("EditorPreferencesMenuLabel", "Editor Preferences..."), LOCTEXT("EditorPreferencesMenuToolTip", "Configure the behavior and features of the Unreal Editor."), FSlateIcon(FEditorStyle::GetStyleSetName(), "EditorPreferences.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FSettingsMenu::OpenSettings, FName("Editor"), FName("General"), FName("Appearance"))) ); #endif MenuBuilder.AddMenuEntry( LOCTEXT("ProjectSettingsMenuLabel", "Project Settings..."), LOCTEXT("ProjectSettingsMenuToolTip", "Change the settings of the currently loaded project."), FSlateIcon(FEditorStyle::GetStyleSetName(), "ProjectSettings.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FSettingsMenu::OpenSettings, FName("Project"), FName("Project"), FName("General"))) ); //@todo The tab system needs to be able to be extendable by plugins [9/3/2013 Justin.Sargent] if (IModularFeatures::Get().IsModularFeatureAvailable(EditorFeatures::PluginsEditor)) { FGlobalTabmanager::Get()->PopulateTabSpawnerMenu(MenuBuilder, "PluginsEditor"); } } } MenuBuilder.EndSection(); }
bool FAssetContextMenu::AddCommonMenuOptions(FMenuBuilder& MenuBuilder) { MenuBuilder.BeginSection("AssetContextActions", LOCTEXT("AssetActionsMenuHeading", "Asset Actions")); { MenuBuilder.AddMenuEntry( LOCTEXT("SyncToAssetTree", "Find in Asset Tree"), LOCTEXT("SyncToAssetTreeTooltip", "Selects the folder in the asset tree containing this asset."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSyncToAssetTree ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSyncToAssetTree ) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("FindAssetInWorld", "Select Actors Using This Asset"), LOCTEXT("FindAssetInWorldTooltip", "Selects all actors referencing this asset."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteFindAssetInWorld ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteFindAssetInWorld ) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("Properties", "Details..."), LOCTEXT("PropertiesTooltip", "Opens the details for the selected assets."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteProperties ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteProperties ) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("PropertyMatrix", "Property Matrix..."), LOCTEXT("PropertyMatrixTooltip", "Opens the property matrix editor for the selected assets."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecutePropertyMatrix ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteProperties ) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("Duplicate", "Create Copy"), LOCTEXT("DuplicateTooltip", "Create a copy of the selected assets."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteDuplicate ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteDuplicate ) ) ); if ( SelectedAssets.Num() == 1 ) { MenuBuilder.AddMenuEntry( FGenericCommands::Get().Rename, NAME_None, LOCTEXT("Rename", "Rename"), LOCTEXT("RenameTooltip", "Rename the selected asset.") ); } MenuBuilder.AddMenuEntry( FGenericCommands::Get().Delete, NAME_None, LOCTEXT("Delete", "Delete"), LOCTEXT("DeleteTooltip", "Delete the selected assets.") ); if ( CanExecuteConsolidate() ) { MenuBuilder.AddMenuEntry( LOCTEXT("Consolidate", "Consolidate"), LOCTEXT("ConsolidateTooltip", "Consolidate the selected assets into one."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteConsolidate ) ) ); } MenuBuilder.AddMenuEntry( LOCTEXT("Export", "Export..."), LOCTEXT("ExportTooltip", "Export the selected assets to file."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteExport ) ) ); if (SelectedAssets.Num() > 1) { MenuBuilder.AddMenuEntry( LOCTEXT("BulkExport", "Bulk Export..."), LOCTEXT("BulkExportTooltip", "Export the selected assets to file in the selected directory"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteBulkExport ) ) ); } MenuBuilder.AddMenuEntry( LOCTEXT("MigrateAsset", "Migrate..."), LOCTEXT("MigrateAssetTooltip", "Copies all selected assets and their dependencies to another game"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteMigrateAsset ) ) ); MenuBuilder.AddMenuEntry( ContentBrowserUtils::GetExploreFolderText(), LOCTEXT("FindInExplorerTooltip", "Finds this asset on disk"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteFindInExplorer ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteFindInExplorer ) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("CreateBlueprintUsing", "Create Blueprint Using..."), LOCTEXT("CreateBlueprintUsingTooltip", "Create a new Blueprint and add this asset to it"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP(this, &FAssetContextMenu::ExecuteCreateBlueprintUsing), FCanExecuteAction::CreateSP(this, &FAssetContextMenu::CanExecuteCreateBlueprintUsing) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("SaveAsset", "Save"), LOCTEXT("SaveAssetTooltip", "Saves the asset to file."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSaveAsset ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSaveAsset ) ) ); if (CanExecuteDiffSelected()) { MenuBuilder.AddMenuEntry( LOCTEXT("DiffSelected", "Diff Selected"), LOCTEXT("DiffSelectedTooltip", "Diff the two assets that you have selected."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP(this, &FAssetContextMenu::ExecuteDiffSelected) ) ); } FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools"); if ( SelectedAssets.Num() == 1 && AssetToolsModule.Get().AssetUsesGenericThumbnail(SelectedAssets[0]) ) { MenuBuilder.AddMenuEntry( LOCTEXT("CaptureThumbnail", "Capture Thumbnail"), LOCTEXT("CaptureThumbnailTooltip", "Captures a thumbnail from the active viewport."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteCaptureThumbnail ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteCaptureThumbnail ) ) ); } if ( CanClearCustomThumbnails() ) { MenuBuilder.AddMenuEntry( LOCTEXT("ClearCustomThumbnail", "Clear Thumbnail"), LOCTEXT("ClearCustomThumbnailTooltip", "Clears all custom thumbnails for selected assets."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteClearThumbnail ) ) ); } } MenuBuilder.EndSection(); return true; }
void SVisualLogger::Construct(const FArguments& InArgs, const TSharedRef<SDockTab>& ConstructUnderMajorTab, const TSharedPtr<SWindow>& ConstructUnderWindow) { bPausedLogger = false; bGotHistogramData = false; FLogVisualizer::Get().SetCurrentVisualizer(SharedThis(this)); ////////////////////////////////////////////////////////////////////////// // Visual Logger Events FLogVisualizer::Get().GetVisualLoggerEvents().OnItemSelectionChanged = FOnItemSelectionChanged::CreateRaw(this, &SVisualLogger::OnItemSelectionChanged); FLogVisualizer::Get().GetVisualLoggerEvents().OnFiltersChanged = FOnFiltersChanged::CreateRaw(this, &SVisualLogger::OnFiltersChanged); FLogVisualizer::Get().GetVisualLoggerEvents().OnObjectSelectionChanged = FOnObjectSelectionChanged::CreateRaw(this, &SVisualLogger::OnObjectSelectionChanged); FLogVisualizer::Get().GetVisualLoggerEvents().OnLogLineSelectionChanged = FOnLogLineSelectionChanged::CreateRaw(this, &SVisualLogger::OnLogLineSelectionChanged); ////////////////////////////////////////////////////////////////////////// // Command Action Lists const FVisualLoggerCommands& Commands = FVisualLoggerCommands::Get(); FUICommandList& ActionList = *CommandList; ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>(); FCategoryFiltersManager::Get().LoadPresistentData(); ActionList.MapAction(Commands.StartRecording, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandIsVisible)); ActionList.MapAction(Commands.StopRecording, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandIsVisible)); ActionList.MapAction(Commands.Pause, FExecuteAction::CreateRaw(this, &SVisualLogger::HandlePauseCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandlePauseCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandlePauseCommandIsVisible)); ActionList.MapAction(Commands.Resume, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleResumeCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleResumeCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleResumeCommandIsVisible)); ActionList.MapAction(Commands.LoadFromVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleLoadCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleLoadCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleLoadCommandCanExecute)); ActionList.MapAction(Commands.SaveToVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute)); ActionList.MapAction(Commands.FreeCamera, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleCameraCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleCameraCommandCanExecute), FIsActionChecked::CreateRaw(this, &SVisualLogger::HandleCameraCommandIsChecked), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleCameraCommandCanExecute)); ActionList.MapAction(Commands.ToggleGraphs, FExecuteAction::CreateLambda([](){bool& bEnableGraphsVisualization = ULogVisualizerSessionSettings::StaticClass()->GetDefaultObject<ULogVisualizerSessionSettings>()->bEnableGraphsVisualization; bEnableGraphsVisualization = !bEnableGraphsVisualization; }), FCanExecuteAction::CreateLambda([this]()->bool{return bGotHistogramData; }), FIsActionChecked::CreateLambda([]()->bool{return ULogVisualizerSessionSettings::StaticClass()->GetDefaultObject<ULogVisualizerSessionSettings>()->bEnableGraphsVisualization; }), FIsActionButtonVisible::CreateLambda([this]()->bool{return bGotHistogramData; })); ActionList.MapAction(Commands.ResetData, FExecuteAction::CreateRaw(this, &SVisualLogger::ResetData), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute)); ActionList.MapAction( Commands.MoveCursorLeft, FExecuteAction::CreateRaw(this, &SVisualLogger::OnMoveCursorLeftCommand)); ActionList.MapAction( Commands.MoveCursorRight, FExecuteAction::CreateRaw(this, &SVisualLogger::OnMoveCursorRightCommand)); // Tab Spawners TabManager = FGlobalTabmanager::Get()->NewTabManager(ConstructUnderMajorTab); TSharedRef<FWorkspaceItem> AppMenuGroup = TabManager->AddLocalWorkspaceMenuCategory(LOCTEXT("VisualLoggerGroupName", "Visual Logger")); TabManager->RegisterTabSpawner(ToolbarTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, ToolbarTabId)) .SetDisplayName(LOCTEXT("ToolbarTabTitle", "Toolbar")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "ToolbarTabIcon")); TabManager->RegisterTabSpawner(FiltersTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, FiltersTabId)) .SetDisplayName(LOCTEXT("FiltersTabTitle", "Filters")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "FiltersTabIcon")); TabManager->RegisterTabSpawner(MainViewTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, MainViewTabId)) .SetDisplayName(LOCTEXT("MainViewTabTitle", "MainView")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "MainViewTabIcon")); TabManager->RegisterTabSpawner(LogsListTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, LogsListTabId)) .SetDisplayName(LOCTEXT("LogsListTabTitle", "LogsList")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "LogsListTabIcon")); TabManager->RegisterTabSpawner(StatusViewTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, StatusViewTabId)) .SetDisplayName(LOCTEXT("StatusViewTabTitle", "StatusView")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "StatusViewTabIcon")); // Default Layout const TSharedRef<FTabManager::FLayout> Layout = FTabManager::NewLayout("VisualLoggerLayout_v1.0") ->AddArea ( FTabManager::NewPrimaryArea() ->SetOrientation(Orient_Vertical) ->Split ( FTabManager::NewStack() ->AddTab(ToolbarTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ) ->Split ( FTabManager::NewStack() ->AddTab(FiltersTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ) ->Split ( FTabManager::NewStack() ->AddTab(MainViewTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ) ->Split ( FTabManager::NewSplitter() ->SetOrientation(Orient_Horizontal) ->SetSizeCoefficient(0.6f) ->Split ( FTabManager::NewStack() ->AddTab(StatusViewTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ->SetSizeCoefficient(0.3f) ) ->Split ( FTabManager::NewStack() ->AddTab(LogsListTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ->SetSizeCoefficient(0.7f) ) ) ); TabManager->SetOnPersistLayout(FTabManager::FOnPersistLayout::CreateRaw(this, &SVisualLogger::HandleTabManagerPersistLayout)); // Load the potentially previously saved new layout TSharedRef<FTabManager::FLayout> UserConfiguredNewLayout = FLayoutSaveRestore::LoadFromConfig(GEditorLayoutIni, Layout); TabManager->RestoreFrom(UserConfiguredNewLayout, TSharedPtr<SWindow>()); // Window Menu FMenuBarBuilder MenuBarBuilder = FMenuBarBuilder(TSharedPtr<FUICommandList>()); #if 0 //disabled File menu for now (SebaK) MenuBarBuilder.AddPullDownMenu( LOCTEXT("FileMenuLabel", "File"), FText::GetEmpty(), FNewMenuDelegate::CreateRaw(this, &SVisualLogger::FillFileMenu, TabManager), "File" ); #endif MenuBarBuilder.AddPullDownMenu( LOCTEXT("WindowMenuLabel", "Window"), FText::GetEmpty(), FNewMenuDelegate::CreateStatic(&SVisualLogger::FillWindowMenu, TabManager), "Window" ); MenuBarBuilder.AddMenuEntry( LOCTEXT("SettingsMenuLabel", "Settings"), FText::GetEmpty(), FSlateIcon(), FUIAction( FExecuteAction::CreateLambda( [this](){ ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings"); if (SettingsModule != nullptr) { SettingsModule->ShowViewer("Editor", "General", "VisualLogger"); } } )), "Settings" ); ChildSlot [ SNew(SVerticalBox) + SVerticalBox::Slot() .AutoHeight() [ MenuBarBuilder.MakeWidget() ] + SVerticalBox::Slot() .FillHeight(1.0f) [ TabManager->RestoreFrom(Layout, ConstructUnderWindow).ToSharedRef() ] ]; VisualLoggerCanvasRenderer = MakeShareable(new FVisualLoggerCanvasRenderer()); DrawOnCanvasDelegateHandle = UDebugDrawService::Register(TEXT("VisLog"), FDebugDrawDelegate::CreateRaw(VisualLoggerCanvasRenderer.Get(), &FVisualLoggerCanvasRenderer::DrawOnCanvas)); //UGameplayDebuggingComponent::OnDebuggingTargetChangedDelegate.AddSP(this, &SVisualLogger::SelectionChanged); }
TSharedRef<SWidget> FAmbientSoundDetails::OnGetSoundCueTemplates() { FMenuBuilder MenuBuilder( true, NULL ); FUIAction EmptyAction( FExecuteAction::CreateSP( this, &FAmbientSoundDetails::CreateNewSoundCue, SOUNDCUE_LAYOUT_EMPTY ) ); MenuBuilder.AddMenuEntry( LOCTEXT("SoundCue_EmptyLayout", "Blank"), LOCTEXT("SoundCue_EmptyLayout_Tooltip", "Create an empty SoundCue"), FSlateIcon(), EmptyAction ); FUIAction MixerAction( FExecuteAction::CreateSP( this, &FAmbientSoundDetails::CreateNewSoundCue, SOUNDCUE_LAYOUT_MIXER ) ); MenuBuilder.AddMenuEntry( LOCTEXT("SoundCue_MixerLayout", "Mixer"), LOCTEXT("SoundCue_MixerLayout_Tooltip", "Create a SoundCue with a Mixer"), FSlateIcon(), MixerAction ); FUIAction RandomLoopAction( FExecuteAction::CreateSP( this, &FAmbientSoundDetails::CreateNewSoundCue, SOUNDCUE_LAYOUT_RANDOM_LOOP ) ); MenuBuilder.AddMenuEntry( LOCTEXT("SoundCue_RandomLoopLayout", "Random Loop"), LOCTEXT("SoundCue_RandomLoopLayout_Tooltip", "Create a SoundCue with a Loop and a Random node"), FSlateIcon(), RandomLoopAction ); FUIAction RandomLoopWithDelayAction( FExecuteAction::CreateSP( this, &FAmbientSoundDetails::CreateNewSoundCue, SOUNDCUE_LAYOUT_RANDOM_LOOP_WITH_DELAY ) ); MenuBuilder.AddMenuEntry( LOCTEXT("SoundCue_RandomLoopWithDelayLayout", "Random Loop with Delay"), LOCTEXT("SoundCue_RandomLoopWithDelayLayout_Tooltip", "Create a SoundCue with a Loop, a Delay, and a Random node"), FSlateIcon(), RandomLoopWithDelayAction ); return MenuBuilder.MakeWidget(); }
void FAssetTypeActions_AkAudioBank::GetActions( const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder ) { auto Banks = GetTypedWeakObjectPtrs<UAkAudioBank>(InObjects); if(Banks.Num() > 1) { MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_GenerateDefinitionFile","Generate Selected SoundBanks..."), LOCTEXT("AkAudioBank_GenerateDefinitionFileTooltip", "Generates the selected SoundBanks."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::GenerateDefinitionFile, Banks ), FCanExecuteAction() ) ); } else { MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_GenerateDefinitionFile","Generate Selected SoundBank..."), LOCTEXT("AkAudioBank_GenerateDefinitionFileTooltip", "Generates the selected SoundBank."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::GenerateDefinitionFile, Banks ), FCanExecuteAction() ) ); } MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_LoadBank","Load Bank"), LOCTEXT("AkAudioBank_LoadBankTooltip", "Loads the bank."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::LoadBank, Banks ), FCanExecuteAction() ) ); MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_UnloadBank","Unload Bank"), LOCTEXT("AkAudioBank_UnloadBankTooltip", "Unloads the bank."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::UnloadBank, Banks ), FCanExecuteAction() ) ); MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_ClearBank","Clear Banks"), LOCTEXT("AkAudioBank_ClearBankTooltip", "Unloads all banks."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::ClearBank, Banks ), FCanExecuteAction() ) ); MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_LoadInitBank","Load Init Bank"), LOCTEXT("AkAudioBank_LoadInitBankTooltip", "Loads the Wwise init bank."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::LoadInitBank, Banks ), FCanExecuteAction() ) ); MenuBuilder.AddMenuEntry( LOCTEXT("AkAudioBank_RefreshAllBanks","Refresh All Banks"), LOCTEXT("AkAudioBank_RefreshAllBanksTooltip", "Refresh all the selected banks."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetTypeActions_AkAudioBank::RefreshAllBanks, Banks ), FCanExecuteAction() ) ); }
void FAssetTypeActions_Class::GetActions(const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder) { UClass *const BaseClass = (InObjects.Num() == 1) ? Cast<UClass>(InObjects[0]) : nullptr; // Only allow the New class option if we have a base class that we can actually derive from in one of our project modules FGameProjectGenerationModule& GameProjectGenerationModule = FGameProjectGenerationModule::Get(); TArray<FModuleContextInfo> ProjectModules = GameProjectGenerationModule.GetCurrentProjectModules(); const bool bIsValidBaseCppClass = BaseClass && GameProjectGenerationModule.IsValidBaseClassForCreation(BaseClass, ProjectModules); const bool bIsValidBaseBlueprintClass = BaseClass && FKismetEditorUtilities::CanCreateBlueprintOfClass(BaseClass); auto CreateCreateDerivedCppClass = [BaseClass]() { // Work out where the header file for the current class is, as we'll use that path as the default for the new class FString BaseClassPath; if(FSourceCodeNavigation::FindClassHeaderPath(BaseClass, BaseClassPath)) { // Strip off the actual filename as we only need the path BaseClassPath = FPaths::GetPath(BaseClassPath); } FGameProjectGenerationModule::Get().OpenAddCodeToProjectDialog( FAddToProjectConfig() .ParentClass(BaseClass) .InitialPath(BaseClassPath) .ParentWindow(FGlobalTabmanager::Get()->GetRootWindow()) ); }; auto CanCreateDerivedCppClass = [bIsValidBaseCppClass]() -> bool { return bIsValidBaseCppClass; }; auto CreateCreateDerivedBlueprintClass = [BaseClass]() { FGameProjectGenerationModule::Get().OpenAddBlueprintToProjectDialog( FAddToProjectConfig() .ParentClass(BaseClass) .ParentWindow(FGlobalTabmanager::Get()->GetRootWindow()) ); }; auto CanCreateDerivedBlueprintClass = [bIsValidBaseBlueprintClass]() -> bool { return bIsValidBaseBlueprintClass; }; FText NewDerivedCppClassLabel; FText NewDerivedCppClassToolTip; FText NewDerivedBlueprintClassLabel; FText NewDerivedBlueprintClassToolTip; if(InObjects.Num() == 1) { const FText BaseClassName = FText::FromName(BaseClass->GetFName()); NewDerivedCppClassLabel = FText::Format(LOCTEXT("Class_NewDerivedCppClassLabel_CreateFrom", "Create C++ class derived from {0}"), BaseClassName); if(bIsValidBaseCppClass) { NewDerivedCppClassToolTip = FText::Format(LOCTEXT("Class_NewDerivedCppClassTooltip_CreateFrom", "Create a new C++ class deriving from {0}."), BaseClassName); } else { NewDerivedCppClassToolTip = FText::Format(LOCTEXT("Class_NewDerivedCppClassTooltip_InvalidClass", "Cannot create a new C++ class deriving from {0}."), BaseClassName); } NewDerivedBlueprintClassLabel = FText::Format(LOCTEXT("Class_NewDerivedBlueprintClassLabel_CreateFrom", "Create Blueprint class based on {0}"), BaseClassName); if(bIsValidBaseBlueprintClass) { NewDerivedBlueprintClassToolTip = FText::Format(LOCTEXT("Class_NewDerivedBlueprintClassTooltip_CreateFrom", "Create a new Blueprint class based on {0}."), BaseClassName); } else { NewDerivedBlueprintClassToolTip = FText::Format(LOCTEXT("Class_NewDerivedBlueprintClassTooltip_InvalidClass", "Cannot create a new Blueprint class based on {0}."), BaseClassName); } } else { NewDerivedCppClassLabel = LOCTEXT("Class_NewDerivedCppClassLabel_InvalidNumberOfBases", "New C++ class derived from..."); NewDerivedCppClassToolTip = LOCTEXT("Class_NewDerivedCppClassTooltip_InvalidNumberOfBases", "Can only create a derived C++ class when there is a single base class selected."); NewDerivedBlueprintClassLabel = LOCTEXT("Class_NewDerivedBlueprintClassLabel_InvalidNumberOfBases", "New Blueprint class based on..."); NewDerivedBlueprintClassToolTip = LOCTEXT("Class_NewDerivedBlueprintClassTooltip_InvalidNumberOfBases", "Can only create a Blueprint class when there is a single base class selected."); } MenuBuilder.AddMenuEntry( NewDerivedCppClassLabel, NewDerivedCppClassToolTip, FSlateIcon(FEditorStyle::GetStyleSetName(), "MainFrame.AddCodeToProject"), FUIAction( FExecuteAction::CreateLambda(CreateCreateDerivedCppClass), FCanExecuteAction::CreateLambda(CanCreateDerivedCppClass) ) ); MenuBuilder.AddMenuEntry( NewDerivedBlueprintClassLabel, NewDerivedBlueprintClassToolTip, FSlateIcon(FEditorStyle::GetStyleSetName(), "LevelEditor.CreateClassBlueprint"), FUIAction( FExecuteAction::CreateLambda(CreateCreateDerivedBlueprintClass), FCanExecuteAction::CreateLambda(CanCreateDerivedBlueprintClass) ) ); }
FReply FKismetDelegateDragDropAction::DroppedOnPanel(const TSharedRef< SWidget >& Panel, FVector2D ScreenPosition, FVector2D GraphPosition, UEdGraph& Graph) { if(IsValid()) { FNodeConstructionParams NewNodeParams; NewNodeParams.Property = GetVariableProperty(); const UClass* VariableSourceClass = CastChecked<UClass>(NewNodeParams.Property->GetOuter()); const UBlueprint* DropOnBlueprint = FBlueprintEditorUtils::FindBlueprintForGraph(&Graph); NewNodeParams.Graph = &Graph; NewNodeParams.GraphPosition = GraphPosition; NewNodeParams.bSelfContext = VariableSourceClass == NULL || DropOnBlueprint->SkeletonGeneratedClass->IsChildOf(VariableSourceClass);; NewNodeParams.AnalyticCallback = AnalyticCallback; FMenuBuilder MenuBuilder(true, NULL); const FText VariableNameText = FText::FromName( VariableName ); MenuBuilder.BeginSection("BPDelegateDroppedOn", VariableNameText ); { const bool bBlueprintCallable = NewNodeParams.Property->HasAllPropertyFlags(CPF_BlueprintCallable); if(bBlueprintCallable) { MenuBuilder.AddMenuEntry( LOCTEXT("CallDelegate", "Call"), FText::Format( LOCTEXT("CallDelegateToolTip", "Call {0}"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetDelegateDragDropAction::MakeMCDelegateNode<UK2Node_CallDelegate>,NewNodeParams) )); } if(NewNodeParams.Property->HasAllPropertyFlags(CPF_BlueprintAssignable)) { MenuBuilder.AddMenuEntry( LOCTEXT("AddDelegate", "Bind"), FText::Format( LOCTEXT("AddDelegateToolTip", "Bind event to {0}"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetDelegateDragDropAction::MakeMCDelegateNode<UK2Node_AddDelegate>,NewNodeParams) )); MenuBuilder.AddMenuEntry( LOCTEXT("AddRemove", "Unbind"), FText::Format( LOCTEXT("RemoveDelegateToolTip", "Unbind event from {0}"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetDelegateDragDropAction::MakeMCDelegateNode<UK2Node_RemoveDelegate>, NewNodeParams) )); MenuBuilder.AddMenuEntry( LOCTEXT("AddClear", "Unbind all"), FText::Format( LOCTEXT("ClearDelegateToolTip", "Unbind all events from {0}"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetDelegateDragDropAction::MakeMCDelegateNode<UK2Node_ClearDelegate>, NewNodeParams) )); const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>(); check(Schema); const EGraphType GraphType = Schema->GetGraphType(&Graph); const bool bSupportsEventGraphs = (DropOnBlueprint && FBlueprintEditorUtils::DoesSupportEventGraphs(DropOnBlueprint)); const bool bAllowEvents = ((GraphType == GT_Ubergraph) && bSupportsEventGraphs); if(bAllowEvents) { MenuBuilder.AddMenuEntry( LOCTEXT("AddEvent", "Event"), FText::Format( LOCTEXT("EventDelegateToolTip", "Create event with the {0} signature"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetDelegateDragDropAction::MakeEvent, NewNodeParams) )); MenuBuilder.AddMenuEntry( LOCTEXT("AssignEvent", "Assign"), LOCTEXT("AssignDelegateToolTip", "Create and bind event"), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetDelegateDragDropAction::AssignEvent, NewNodeParams) )); } } } MenuBuilder.EndSection(); FSlateApplication::Get().PushMenu(Owner, MenuBuilder.MakeWidget(), ScreenPosition, FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu)); } return FReply::Handled(); }
static void AddSaveMenuOption( FMenuBuilder& MenuBuilder ) { MenuBuilder.AddMenuEntry( FTranslationEditorCommands::Get().SaveTranslations, "SaveTranslations", TAttribute<FText>(), TAttribute<FText>(), FSlateIcon(FEditorStyle::GetStyleSetName(), "AssetEditor.SaveAsset.Greyscale") ); }
bool FAssetContextMenu::AddSourceControlMenuOptions(FMenuBuilder& MenuBuilder) { MenuBuilder.BeginSection("AssetContextSourceControl", LOCTEXT("AssetSCCOptionsMenuHeading", "Source Control")); if ( ISourceControlModule::Get().IsEnabled() ) { if( CanExecuteSCCSync() ) { MenuBuilder.AddMenuEntry( LOCTEXT("SCCSync", "Sync"), LOCTEXT("SCCSyncTooltip", "Updates the item to the latest version in source control."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCSync ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCSync ) ) ); } if ( CanExecuteSCCCheckOut() ) { MenuBuilder.AddMenuEntry( LOCTEXT("SCCCheckOut", "Check Out"), LOCTEXT("SCCCheckOutTooltip", "Checks out the selected asset from source control."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCCheckOut ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCCheckOut ) ) ); } if ( CanExecuteSCCOpenForAdd() ) { MenuBuilder.AddMenuEntry( LOCTEXT("SCCOpenForAdd", "Mark For Add"), LOCTEXT("SCCOpenForAddTooltip", "Adds the selected asset to source control."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCOpenForAdd ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCOpenForAdd ) ) ); } if ( CanExecuteSCCCheckIn() ) { MenuBuilder.AddMenuEntry( LOCTEXT("SCCCheckIn", "Check In"), LOCTEXT("SCCCheckInTooltip", "Checks in the selected asset to source control."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCCheckIn ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCCheckIn ) ) ); } MenuBuilder.AddMenuEntry( LOCTEXT("SCCRefresh", "Refresh"), LOCTEXT("SCCRefreshTooltip", "Updates the source control status of the asset."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCRefresh ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCRefresh ) ) ); if( CanExecuteSCCHistory() ) { MenuBuilder.AddMenuEntry( LOCTEXT("SCCHistory", "History"), LOCTEXT("SCCHistoryTooltip", "Displays the source control revision history of the selected asset."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCHistory ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCHistory ) ) ); MenuBuilder.AddMenuEntry( LOCTEXT("SCCDiffAgainstDepot", "Diff Against Depot"), LOCTEXT("SCCDiffAgainstDepotTooltip", "Look at differences between your version of the asset and that in source control."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCDiffAgainstDepot ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCDiffAgainstDepot ) ) ); } if( CanExecuteSCCRevert() ) { MenuBuilder.AddMenuEntry( LOCTEXT("SCCRevert", "Revert"), LOCTEXT("SCCRevertTooltip", "Reverts the asset to the state it was before it was checked out."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteSCCRevert ), FCanExecuteAction::CreateSP( this, &FAssetContextMenu::CanExecuteSCCRevert ) ) ); } } else { MenuBuilder.AddMenuEntry( LOCTEXT("SCCConnectToSourceControl", "Connect To Source Control"), LOCTEXT("SCCConnectToSourceControlTooltip", "Connect to source control to allow source control operations to be performed on content and levels."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FAssetContextMenu::ExecuteEnableSourceControl ), FCanExecuteAction() ) ); } MenuBuilder.EndSection(); return true; }
static void AddToolbarButtons( FToolBarBuilder& ToolbarBuilder ) { ToolbarBuilder.AddToolBarButton( FTranslationEditorCommands::Get().SaveTranslations, "SaveTranslations", TAttribute<FText>(), TAttribute<FText>(), FSlateIcon(FEditorStyle::GetStyleSetName(), "AssetEditor.SaveAsset")); }
TSharedPtr<SWidget> FCollectionContextMenu::MakeCollectionTreeContextMenu(TSharedPtr< FUICommandList > InCommandList) { // Get all menu extenders for this context menu from the content browser module FContentBrowserModule& ContentBrowserModule = FModuleManager::GetModuleChecked<FContentBrowserModule>( TEXT("ContentBrowser") ); TArray<FContentBrowserMenuExtender> MenuExtenderDelegates = ContentBrowserModule.GetAllCollectionListContextMenuExtenders(); TArray<TSharedPtr<FExtender>> Extenders; for (int32 i = 0; i < MenuExtenderDelegates.Num(); ++i) { if (MenuExtenderDelegates[i].IsBound()) { Extenders.Add(MenuExtenderDelegates[i].Execute()); } } TSharedPtr<FExtender> MenuExtender = FExtender::Combine(Extenders); FMenuBuilder MenuBuilder(/*bInShouldCloseWindowAfterMenuSelection=*/true, InCommandList, MenuExtender); UpdateProjectSourceControl(); TArray<TSharedPtr<FCollectionItem>> SelectedCollections = CollectionView.Pin()->CollectionTreePtr->GetSelectedItems(); bool bAnyManagedBySCC = false; bool bAnyNeedSCCUpdate = false; bool bAnyNeedSave = false; for (int32 CollectionIdx = 0; CollectionIdx < SelectedCollections.Num(); ++CollectionIdx) { bAnyManagedBySCC |= SelectedCollections[CollectionIdx]->CollectionType != ECollectionShareType::CST_Local; bAnyNeedSCCUpdate |= SelectedCollections[CollectionIdx]->CurrentStatus == ECollectionItemStatus::IsOutOfDate; bAnyNeedSave |= SelectedCollections[CollectionIdx]->CurrentStatus == ECollectionItemStatus::HasLocalChanges; if (bAnyManagedBySCC && bAnyNeedSCCUpdate && bAnyNeedSave) { // Found collections to turn all options on, break now break; } } MenuBuilder.BeginSection("CollectionOptions", LOCTEXT("CollectionListOptionsMenuHeading", "Collection Options")); { const bool bHasSingleSelectedCollection = SelectedCollections.Num() == 1; const bool bIsFirstSelectedCollectionStatic = SelectedCollections.Num() > 0 && SelectedCollections[0]->StorageMode == ECollectionStorageMode::Static; // New... (submenu) MenuBuilder.AddSubMenu( LOCTEXT("NewChildCollection", "New..."), LOCTEXT("NewChildCollectionTooltip", "Create child a collection."), FNewMenuDelegate::CreateRaw( this, &FCollectionContextMenu::MakeNewCollectionSubMenu, ECollectionStorageMode::Static, SCollectionView::FCreateCollectionPayload( FCollectionNameType( SelectedCollections[0]->CollectionName, SelectedCollections[0]->CollectionType ) ) ), FUIAction( FExecuteAction(), FCanExecuteAction::CreateLambda( [=]{ return bHasSingleSelectedCollection && bIsFirstSelectedCollectionStatic; } ) ), NAME_None, EUserInterfaceActionType::Button ); // Rename MenuBuilder.AddMenuEntry( FGenericCommands::Get().Rename, NAME_None, LOCTEXT("RenameCollection", "Rename"), LOCTEXT("RenameCollectionTooltip", "Rename this collection.")); // Set Share Type MenuBuilder.AddSubMenu( LOCTEXT("SetCollectionShareType", "Set Share Type"), LOCTEXT("SetCollectionShareTypeTooltip", "Change the share type of this collection."), FNewMenuDelegate::CreateRaw( this, &FCollectionContextMenu::MakeCollectionShareTypeSubMenu ), FUIAction( FExecuteAction(), FCanExecuteAction::CreateLambda( [=]{ return bHasSingleSelectedCollection; } ) ), NAME_None, EUserInterfaceActionType::Button ); // If any colors have already been set, display color options as a sub menu if ( CollectionViewUtils::HasCustomColors() ) { // Set Color (submenu) MenuBuilder.AddSubMenu( LOCTEXT("SetColor", "Set Color"), LOCTEXT("SetCollectionColorTooltip", "Sets the color this collection should appear as."), FNewMenuDelegate::CreateRaw( this, &FCollectionContextMenu::MakeSetColorSubMenu ) ); } else { // Set Color MenuBuilder.AddMenuEntry( LOCTEXT("SetColor", "Set Color"), LOCTEXT("SetCollectionColorTooltip", "Sets the color this collection should appear as."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecutePickColor ) ) ); } } MenuBuilder.EndSection(); if ( SelectedCollections.Num() > 0 ) { MenuBuilder.BeginSection("CollectionBulkOperations", LOCTEXT("CollectionListBulkOperationsMenuHeading", "Bulk Operations")); { // Save MenuBuilder.AddMenuEntry( LOCTEXT("SaveCollection", "Save"), LOCTEXT("SaveCollectionTooltip", "Save this collection."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteSaveCollection ), FCanExecuteAction::CreateLambda( [=]{ return bAnyNeedSave; } ) ) ); // Delete MenuBuilder.AddMenuEntry( LOCTEXT("DestroyCollection", "Delete"), LOCTEXT("DestroyCollectionTooltip", "Delete this collection."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteDestroyCollection ), FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteDestroyCollection, bAnyManagedBySCC ) ) ); // Update MenuBuilder.AddMenuEntry( LOCTEXT("UpdateCollection", "Update"), LOCTEXT("UpdateCollectionTooltip", "Update this collection to make sure it's using the latest version from source control."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteUpdateCollection ), FCanExecuteAction::CreateLambda( [=]{ return bAnyNeedSCCUpdate; } ) ) ); } MenuBuilder.EndSection(); } return MenuBuilder.MakeWidget(); }
void FCreatureAnimStateMachineEditor::RegisterTabSpawners(const TSharedRef<class FTabManager>& TabManager) { GraphEditorCommands = MakeShareable(new FUICommandList()); FAssetEditorToolkit::RegisterTabSpawners(TabManager); //蓝图编辑器命令绑定 GraphEditorCommands->MapAction(FGenericCommands::Get().Delete, FExecuteAction::CreateSP(this,&FCreatureAnimStateMachineEditor::OnDeleteNode) ); /*NodeAction.OnSelectionChanged.BindLambda( [&](const FGraphPanelSelectionSet& selection){ for (auto obj : selection) { if (UCreatureAnimStateNode* Node =Cast<UCreatureAnimStateNode>(obj)) { EditGraph->NotifyGraphChanged(); } } } );*/ EditGraph =SNew(SGraphEditor) .GraphToEdit(EditingStateMachine->StateMachineGraph) .IsEditable(true) .AdditionalCommands(GraphEditorCommands) .GraphEvents(NodeAction) ; //将细节面板放入左侧面板 TabManager->RegisterTabSpawner(FName(TEXT("Details")), FOnSpawnTab::CreateLambda( [&](const FSpawnTabArgs& Args){ TSharedPtr<FCreatureAnimStateMachineEditor> StateMechineEditorPtr = SharedThis(this); // Spawn the tab return SNew(SDockTab) .Icon(FEditorStyle::GetBrush("LevelEditor.Tabs.Details")) .Label(LOCTEXT("DetailsTab_Title", "Details")) [ SNew(SCreatureAnimStateMachinePropertiesTabBody,StateMechineEditorPtr) ]; } )) .SetDisplayName(LOCTEXT("DetailsTabLabel", "Details")) .SetIcon(FSlateIcon(FEditorStyle::GetStyleSetName(), "LevelEditor.Tabs.Details")); TabManager->RegisterTabSpawner(FName(TEXT("BluePrint")), FOnSpawnTab::CreateLambda( //用于产生布局的Lambda表达式 [&](const FSpawnTabArgs& Args){ return SNew(SDockTab) .Icon(FEditorStyle::GetBrush("LevelEditor.Tabs.Details")) .Label(LOCTEXT("BlueprintTab_Title", "Blueprint")) [ EditGraph.ToSharedRef()//Slate允许提供一个sharedRef,不需要原地构建控件 ]; } )) .SetDisplayName(LOCTEXT("DetailsTabLabel", "Details")) .SetIcon(FSlateIcon(FEditorStyle::GetStyleSetName(), "LevelEditor.Tabs.Details")); }
FReply FKismetVariableDragDropAction::DroppedOnPanel( const TSharedRef< SWidget >& Panel, FVector2D ScreenPosition, FVector2D GraphPosition, UEdGraph& Graph) { if (Cast<const UEdGraphSchema_K2>(Graph.GetSchema()) != NULL) { UProperty* VariableProperty = GetVariableProperty(); if (VariableProperty != nullptr && CanVariableBeDropped(VariableProperty, Graph)) { UStruct* Outer = CastChecked<UStruct>(VariableProperty->GetOuter()); FNodeConstructionParams NewNodeParams; NewNodeParams.VariableName = VariableName; NewNodeParams.Graph = &Graph; NewNodeParams.GraphPosition = GraphPosition; NewNodeParams.VariableSource= Outer; // call analytics AnalyticCallback.ExecuteIfBound(); // Take into account current state of modifier keys in case the user changed his mind auto ModifierKeys = FSlateApplication::Get().GetModifierKeys(); const bool bModifiedKeysActive = ModifierKeys.IsControlDown() || ModifierKeys.IsAltDown(); const bool bAutoCreateGetter = bModifiedKeysActive ? ModifierKeys.IsControlDown() : bControlDrag; const bool bAutoCreateSetter = bModifiedKeysActive ? ModifierKeys.IsAltDown() : bAltDrag; // Handle Getter/Setters if (bAutoCreateGetter || bAutoCreateSetter) { if (bAutoCreateGetter || !CanExecuteMakeSetter(NewNodeParams, VariableProperty)) { MakeGetter(NewNodeParams); NewNodeParams.GraphPosition.Y += 50.f; } if (bAutoCreateSetter && CanExecuteMakeSetter( NewNodeParams, VariableProperty)) { MakeSetter(NewNodeParams); } } // Show selection menu else { FMenuBuilder MenuBuilder(true, NULL); const FText VariableNameText = FText::FromName( VariableName ); MenuBuilder.BeginSection("BPVariableDroppedOn", VariableNameText ); MenuBuilder.AddMenuEntry( LOCTEXT("CreateGetVariable", "Get"), FText::Format( LOCTEXT("CreateVariableGetterToolTip", "Create Getter for variable '{0}'\n(Ctrl-drag to automatically create a getter)"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetVariableDragDropAction::MakeGetter, NewNodeParams), FCanExecuteAction()) ); MenuBuilder.AddMenuEntry( LOCTEXT("CreateSetVariable", "Set"), FText::Format( LOCTEXT("CreateVariableSetterToolTip", "Create Setter for variable '{0}'\n(Alt-drag to automatically create a setter)"), VariableNameText ), FSlateIcon(), FUIAction( FExecuteAction::CreateStatic(&FKismetVariableDragDropAction::MakeSetter, NewNodeParams), FCanExecuteAction::CreateStatic(&FKismetVariableDragDropAction::CanExecuteMakeSetter, NewNodeParams, VariableProperty )) ); TSharedRef< SWidget > PanelWidget = Panel; // Show dialog to choose getter vs setter FSlateApplication::Get().PushMenu( PanelWidget, FWidgetPath(), MenuBuilder.MakeWidget(), ScreenPosition, FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu) ); MenuBuilder.EndSection(); } } } return FReply::Handled(); }
TSharedRef<SWidget> FBehaviorDecoratorDetails::OnGetAbortModeContent() const { FMenuBuilder MenuBuilder(true, NULL); for (int32 i = 0; i < ModeValues.Num(); i++) { FUIAction ItemAction( FExecuteAction::CreateSP( this, &FBehaviorDecoratorDetails::OnAbortModeChange, ModeValues[i].Int ) ); MenuBuilder.AddMenuEntry(FText::FromString( ModeValues[i].Str ), TAttribute<FText>(), FSlateIcon(), ItemAction); } return MenuBuilder.MakeWidget(); }
TSharedRef<SWidget> FLandscapeEditorDetails::GetTargetLandscapeMenu() { FEdModeLandscape* LandscapeEdMode = GetEditorMode(); if (LandscapeEdMode) { FMenuBuilder MenuBuilder(true, NULL); const TArray<FLandscapeListInfo>& LandscapeList = LandscapeEdMode->GetLandscapeList(); for (auto It = LandscapeList.CreateConstIterator(); It; It++) { FUIAction Action = FUIAction(FExecuteAction::CreateStatic(&FLandscapeEditorDetails::OnChangeTargetLandscape, TWeakObjectPtr<ULandscapeInfo>(It->Info))); MenuBuilder.AddMenuEntry(FText::FromString(It->Info->GetLandscapeProxy()->GetActorLabel()), FText(), FSlateIcon(), Action); } return MenuBuilder.MakeWidget(); } return SNullWidget::NullWidget; }
TSharedRef<SWidget> FCurveAssetEditor::BuildOutputSnapMenu() { FMenuBuilder MenuBuilder(true, NULL); FUIAction OneThousandthAction(FExecuteAction::CreateSP(this, &FCurveAssetEditor::SetOutputSnap, 0.001f)); MenuBuilder.AddMenuEntry(LOCTEXT("OutputSnap_OneThousandth", "0.001"), LOCTEXT("OutputSnap_OneThousandth", "Set snap to 1/1000th"), FSlateIcon(), OneThousandthAction); FUIAction OneHundredthAction(FExecuteAction::CreateSP(this, &FCurveAssetEditor::SetOutputSnap, 0.01f)); MenuBuilder.AddMenuEntry(LOCTEXT("OutputSnap_OneHundredth", "0.01"), LOCTEXT("OutputSnap_OneHundredth", "Set snap to 1/100th"), FSlateIcon(), OneHundredthAction); FUIAction OneTenthAction(FExecuteAction::CreateSP(this, &FCurveAssetEditor::SetOutputSnap, 0.1f)); MenuBuilder.AddMenuEntry(LOCTEXT("OutputSnap_OneTenth", "0.1"), LOCTEXT("OutputSnap_OneTenth", "Set snap to 1/10th"), FSlateIcon(), OneTenthAction); FUIAction OneAction(FExecuteAction::CreateSP(this, &FCurveAssetEditor::SetOutputSnap, 1.0f)); MenuBuilder.AddMenuEntry(LOCTEXT("OutputSnap_One", "1"), LOCTEXT("OutputSnap_One", "Set snap to 1h"), FSlateIcon(), OneAction); FUIAction TenAction(FExecuteAction::CreateSP(this, &FCurveAssetEditor::SetOutputSnap, 10.0f)); MenuBuilder.AddMenuEntry(LOCTEXT("OutputSnap_Ten", "10"), LOCTEXT("OutputSnap_Ten", "Set snap to 10"), FSlateIcon(), TenAction); FUIAction HundredAction(FExecuteAction::CreateSP(this, &FCurveAssetEditor::SetOutputSnap, 100.0f)); MenuBuilder.AddMenuEntry(LOCTEXT("OutputSnap_OneHundred", "100"), LOCTEXT("OutputSnap_OneHundred", "Set snap to 100"), FSlateIcon(), HundredAction); return MenuBuilder.MakeWidget(); }
static void PopulateSpriteActionsMenu(FMenuBuilder& MenuBuilder, TArray<FAssetData> SelectedAssets) { // Create sprites TSharedPtr<FCreateSpriteFromTextureExtension> SpriteCreatorFunctor = MakeShareable(new FCreateSpriteFromTextureExtension()); SpriteCreatorFunctor->SelectedAssets = SelectedAssets; FUIAction Action_CreateSpritesFromTextures( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(SpriteCreatorFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_CreateSprite", "Create Sprite"), LOCTEXT("CB_Extension_Texture_CreateSprite_Tooltip", "Create sprites from selected textures"), FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.PaperSprite"), Action_CreateSpritesFromTextures, NAME_None, EUserInterfaceActionType::Button); // Extract Sprites TSharedPtr<FCreateSpriteFromTextureExtension> SpriteExtractorFunctor = MakeShareable(new FCreateSpriteFromTextureExtension()); SpriteExtractorFunctor->SelectedAssets = SelectedAssets; SpriteExtractorFunctor->bExtractSprites = true; FUIAction Action_ExtractSpritesFromTextures( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(SpriteExtractorFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_ExtractSprites", "Extract Sprites"), LOCTEXT("CB_Extension_Texture_ExtractSprite_Tooltip", "Detects and extracts sprites from the selected textures using transparency"), FSlateIcon(), Action_ExtractSpritesFromTextures, NAME_None, EUserInterfaceActionType::Button); // Configure for retro sprites TSharedPtr<FConfigureTexturesForSpriteUsageExtension> TextureConfigFunctor = MakeShareable(new FConfigureTexturesForSpriteUsageExtension()); TextureConfigFunctor->SelectedAssets = SelectedAssets; FUIAction Action_ConfigureTexturesForSprites( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(TextureConfigFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_ConfigureTextureForSprites", "Configure For Retro Sprites"), LOCTEXT("CB_Extension_Texture_ConfigureTextureForSprites_Tooltip", "Sets compression settings and sampling modes to good defaults for retro sprites (nearest filtering, uncompressed, etc...)"), FSlateIcon(), Action_ConfigureTexturesForSprites, NAME_None, EUserInterfaceActionType::Button); // Create sprites TSharedPtr<FCreateTileSetFromTextureExtension> TileSetCreatorFunctor = MakeShareable(new FCreateTileSetFromTextureExtension()); TileSetCreatorFunctor->SelectedAssets = SelectedAssets; FUIAction Action_CreateTileSetFromTextures( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(TileSetCreatorFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_CreateTileSet", "Create Tile Set"), LOCTEXT("CB_Extension_Texture_CreateTileSet_Tooltip", "Create tile set from selected texture"), FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.PaperTileSet"), Action_CreateTileSetFromTextures, NAME_None, EUserInterfaceActionType::Button); }
void SSessionLauncherCookPage::Construct( const FArguments& InArgs, const FSessionLauncherModelRef& InModel ) { Model = InModel; // create cook modes menu FMenuBuilder CookModeMenuBuilder(true, NULL); { FUIAction ByTheBookAction(FExecuteAction::CreateSP(this, &SSessionLauncherCookPage::HandleCookModeMenuEntryClicked, ELauncherProfileCookModes::ByTheBook)); CookModeMenuBuilder.AddMenuEntry(LOCTEXT("ByTheBookAction", "By the book"), LOCTEXT("ByTheBookActionHint", "Specify which content should be cooked and cook everything in advance prior to launching the game."), FSlateIcon(), ByTheBookAction); FUIAction OnTheFlyAction(FExecuteAction::CreateSP(this, &SSessionLauncherCookPage::HandleCookModeMenuEntryClicked, ELauncherProfileCookModes::OnTheFly)); CookModeMenuBuilder.AddMenuEntry(LOCTEXT("OnTheFlyAction", "On the fly"), LOCTEXT("OnTheFlyActionHint", "Cook the content at run-time before it is being sent to the device."), FSlateIcon(), OnTheFlyAction); FUIAction DoNotCookAction(FExecuteAction::CreateSP(this, &SSessionLauncherCookPage::HandleCookModeMenuEntryClicked, ELauncherProfileCookModes::DoNotCook)); CookModeMenuBuilder.AddMenuEntry(LOCTEXT("DoNotCookAction", "Do not cook"), LOCTEXT("DoNotCookActionHint", "Do not cook the content at this time."), FSlateIcon(), DoNotCookAction); } ChildSlot [ SNew(SVerticalBox) + SVerticalBox::Slot() .AutoHeight() [ SNew(SHorizontalBox) + SHorizontalBox::Slot() .FillWidth(1.0) .VAlign(VAlign_Center) [ SNew(STextBlock) .Text(LOCTEXT("HowToCookText", "How would you like to cook the content?")) ] + SHorizontalBox::Slot() .AutoWidth() .Padding(8.0, 0.0, 0.0, 0.0) [ // cooking mode menu SNew(SComboButton) .ButtonContent() [ SNew(STextBlock) .Text(this, &SSessionLauncherCookPage::HandleCookModeComboButtonContentText) ] .ContentPadding(FMargin(6.0, 2.0)) .MenuContent() [ CookModeMenuBuilder.MakeWidget() ] ] ] + SVerticalBox::Slot() .AutoHeight() .Padding(0.0, 8.0, 0.0, 0.0) [ SNew(SSessionLauncherCookOnTheFlySettings, InModel) .Visibility(this, &SSessionLauncherCookPage::HandleCookOnTheFlySettingsVisibility) ] + SVerticalBox::Slot() .AutoHeight() .Padding(0.0, 8.0, 0.0, 0.0) [ SNew(SSessionLauncherCookByTheBookSettings, InModel) .Visibility(this, &SSessionLauncherCookPage::HandleCookByTheBookSettingsVisibility) ] ]; Model->OnProfileSelected().AddSP(this, &SSessionLauncherCookPage::HandleProfileManagerProfileSelected); }
void FPathContextMenu::MakePathViewContextMenu(FMenuBuilder& MenuBuilder) { int32 NumAssetPaths, NumClassPaths; ContentBrowserUtils::CountPathTypes(SelectedPaths, NumAssetPaths, NumClassPaths); // Only add something if at least one folder is selected if ( SelectedPaths.Num() > 0 ) { const bool bHasAssetPaths = NumAssetPaths > 0; const bool bHasClassPaths = NumClassPaths > 0; // Common operations section // MenuBuilder.BeginSection("PathViewFolderOptions", LOCTEXT("PathViewOptionsMenuHeading", "Folder Options") ); { if(bHasAssetPaths) { FText NewAssetToolTip; if(SelectedPaths.Num() == 1) { if(CanCreateAsset()) { NewAssetToolTip = FText::Format(LOCTEXT("NewAssetTooltip_CreateIn", "Create a new asset in {0}."), FText::FromString(SelectedPaths[0])); } else { NewAssetToolTip = FText::Format(LOCTEXT("NewAssetTooltip_InvalidPath", "Cannot create new assets in {0}."), FText::FromString(SelectedPaths[0])); } } else { NewAssetToolTip = LOCTEXT("NewAssetTooltip_InvalidNumberOfPaths", "Can only create assets when there is a single path selected."); } // New Asset (submenu) MenuBuilder.AddSubMenu( LOCTEXT( "NewAssetLabel", "New Asset" ), NewAssetToolTip, FNewMenuDelegate::CreateRaw( this, &FPathContextMenu::MakeNewAssetSubMenu ), FUIAction( FExecuteAction(), FCanExecuteAction::CreateRaw( this, &FPathContextMenu::CanCreateAsset ) ), NAME_None, EUserInterfaceActionType::Button, false, FSlateIcon() ); } if(bHasClassPaths) { FText NewClassToolTip; if(SelectedPaths.Num() == 1) { if(CanCreateClass()) { NewClassToolTip = FText::Format(LOCTEXT("NewClassTooltip_CreateIn", "Create a new class in {0}."), FText::FromString(SelectedPaths[0])); } else { NewClassToolTip = FText::Format(LOCTEXT("NewClassTooltip_InvalidPath", "Cannot create new classes in {0}."), FText::FromString(SelectedPaths[0])); } } else { NewClassToolTip = LOCTEXT("NewClassTooltip_InvalidNumberOfPaths", "Can only create classes when there is a single path selected."); } // New Class MenuBuilder.AddMenuEntry( LOCTEXT("NewClassLabel", "New C++ Class..."), NewClassToolTip, FSlateIcon(FEditorStyle::GetStyleSetName(), "MainFrame.AddCodeToProject"), FUIAction( FExecuteAction::CreateRaw( this, &FPathContextMenu::ExecuteCreateClass ), FCanExecuteAction::CreateRaw( this, &FPathContextMenu::CanCreateClass ) ) ); } // Explore MenuBuilder.AddMenuEntry( ContentBrowserUtils::GetExploreFolderText(), LOCTEXT("ExploreTooltip", "Finds this folder on disk."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteExplore ) ) ); MenuBuilder.AddMenuEntry(FGenericCommands::Get().Rename, NAME_None, LOCTEXT("RenameFolder", "Rename"), LOCTEXT("RenameFolderTooltip", "Rename the selected folder.") ); // If any colors have already been set, display color options as a sub menu if ( ContentBrowserUtils::HasCustomColors() ) { // Set Color (submenu) MenuBuilder.AddSubMenu( LOCTEXT("SetColor", "Set Color"), LOCTEXT("SetColorTooltip", "Sets the color this folder should appear as."), FNewMenuDelegate::CreateRaw( this, &FPathContextMenu::MakeSetColorSubMenu ), false, FSlateIcon() ); } else { // Set Color MenuBuilder.AddMenuEntry( LOCTEXT("SetColor", "Set Color"), LOCTEXT("SetColorTooltip", "Sets the color this folder should appear as."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecutePickColor ) ) ); } } MenuBuilder.EndSection(); if(bHasAssetPaths) { // Bulk operations section // MenuBuilder.BeginSection("PathContextBulkOperations", LOCTEXT("AssetTreeBulkMenuHeading", "Bulk Operations") ); { // Save MenuBuilder.AddMenuEntry( LOCTEXT("SaveFolder", "Save All"), LOCTEXT("SaveFolderTooltip", "Saves all modified assets in this folder."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSaveFolder ) ) ); // Delete MenuBuilder.AddMenuEntry(FGenericCommands::Get().Delete, NAME_None, LOCTEXT("DeleteFolder", "Delete"), LOCTEXT("DeleteFolderTooltip", "Removes this folder and all assets it contains."), FSlateIcon() ); // Reference Viewer MenuBuilder.AddMenuEntry( LOCTEXT("ReferenceViewer", "Reference Viewer..."), LOCTEXT("ReferenceViewerOnFolderTooltip", "Shows a graph of references for this folder."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteReferenceViewer ) ) ); // Size Map MenuBuilder.AddMenuEntry( LOCTEXT("SizeMap", "Size Map..."), LOCTEXT("SizeMapOnFolderTooltip", "Shows an interactive map of the approximate memory used by the assets in this folder and everything they reference."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSizeMap ) ) ); // Fix Up Redirectors in Folder MenuBuilder.AddMenuEntry( LOCTEXT("FixUpRedirectorsInFolder", "Fix Up Redirectors in Folder"), LOCTEXT("FixUpRedirectorsInFolderTooltip", "Finds referencers to all redirectors in the selected folders and resaves them if possible, then deletes any redirectors that had all their referencers fixed."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteFixUpRedirectorsInFolder ) ) ); if ( NumAssetPaths == 1 && NumClassPaths == 0 ) { // Migrate Folder MenuBuilder.AddMenuEntry( LOCTEXT("MigrateFolder", "Migrate..."), LOCTEXT("MigrateFolderTooltip", "Copies assets found in this folder and their dependencies to another game content folder."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteMigrateFolder ) ) ); } } MenuBuilder.EndSection(); // Source control section // MenuBuilder.BeginSection("PathContextSourceControl", LOCTEXT("AssetTreeSCCMenuHeading", "Source Control") ); ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider(); if ( SourceControlProvider.IsEnabled() ) { // Check out MenuBuilder.AddMenuEntry( LOCTEXT("FolderSCCCheckOut", "Check Out"), LOCTEXT("FolderSCCCheckOutTooltip", "Checks out all assets from source control which are in this folder."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSCCCheckOut ), FCanExecuteAction::CreateSP( this, &FPathContextMenu::CanExecuteSCCCheckOut ) ) ); // Open for Add MenuBuilder.AddMenuEntry( LOCTEXT("FolderSCCOpenForAdd", "Mark For Add"), LOCTEXT("FolderSCCOpenForAddTooltip", "Adds all assets to source control that are in this folder and not already added."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSCCOpenForAdd ), FCanExecuteAction::CreateSP( this, &FPathContextMenu::CanExecuteSCCOpenForAdd ) ) ); // Check in MenuBuilder.AddMenuEntry( LOCTEXT("FolderSCCCheckIn", "Check In"), LOCTEXT("FolderSCCCheckInTooltip", "Checks in all assets to source control which are in this folder."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSCCCheckIn ), FCanExecuteAction::CreateSP( this, &FPathContextMenu::CanExecuteSCCCheckIn ) ) ); // Sync MenuBuilder.AddMenuEntry( LOCTEXT("FolderSCCSync", "Sync"), LOCTEXT("FolderSCCSyncTooltip", "Syncs all the assets in this folder to the latest version."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSCCSync ), FCanExecuteAction::CreateSP( this, &FPathContextMenu::CanExecuteSCCSync ) ) ); } else { MenuBuilder.AddMenuEntry( LOCTEXT("FolderSCCConnect", "Connect To Source Control"), LOCTEXT("FolderSCCConnectTooltip", "Connect to source control to allow source control operations to be performed on content and levels."), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &FPathContextMenu::ExecuteSCCConnect ), FCanExecuteAction::CreateSP( this, &FPathContextMenu::CanExecuteSCCConnect ) ) ); } MenuBuilder.EndSection(); } } }
/** * Constructs the widget * * @param InArgs Declaration from which to construct this widget. */ void SDetailsView::Construct(const FArguments& InArgs) { DetailsViewArgs = InArgs._DetailsViewArgs; bViewingClassDefaultObject = false; PropertyUtilities = MakeShareable( new FPropertyDetailsUtilities( *this ) ); ColumnSizeData.LeftColumnWidth = TAttribute<float>( this, &SDetailsView::OnGetLeftColumnWidth ); ColumnSizeData.RightColumnWidth = TAttribute<float>( this, &SDetailsView::OnGetRightColumnWidth ); ColumnSizeData.OnWidthChanged = SSplitter::FOnSlotResized::CreateSP( this, &SDetailsView::OnSetColumnWidth ); // We want the scrollbar to always be visible when objects are selected, but not when there is no selection - however: // - We can't use AlwaysShowScrollbar for this, as this will also show the scrollbar when nothing is selected // - We can't use the Visibility construction parameter, as it gets translated into user visibility and can hide the scrollbar even when objects are selected // We instead have to explicitly set the visibility after the scrollbar has been constructed to get the exact behavior we want TSharedRef<SScrollBar> ExternalScrollbar = SNew(SScrollBar); ExternalScrollbar->SetVisibility( TAttribute<EVisibility>( this, &SDetailsView::GetScrollBarVisibility ) ); FMenuBuilder DetailViewOptions( true, nullptr); if (DetailsViewArgs.bShowModifiedPropertiesOption) { DetailViewOptions.AddMenuEntry( LOCTEXT("ShowOnlyModified", "Show Only Modified Properties"), LOCTEXT("ShowOnlyModified_ToolTip", "Displays only properties which have been changed from their default"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &SDetailsView::OnShowOnlyModifiedClicked ), FCanExecuteAction(), FIsActionChecked::CreateSP( this, &SDetailsView::IsShowOnlyModifiedChecked ) ), NAME_None, EUserInterfaceActionType::ToggleButton ); } if( DetailsViewArgs.bShowDifferingPropertiesOption ) { DetailViewOptions.AddMenuEntry( LOCTEXT("ShowOnlyDiffering", "Show Only Differing Properties"), LOCTEXT("ShowOnlyDiffering_ToolTip", "Displays only properties in this instance which have been changed or added from the instance being compared"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP(this, &SDetailsView::OnShowOnlyDifferingClicked), FCanExecuteAction(), FIsActionChecked::CreateSP(this, &SDetailsView::IsShowOnlyDifferingChecked) ), NAME_None, EUserInterfaceActionType::ToggleButton ); } DetailViewOptions.AddMenuEntry( LOCTEXT("ShowAllAdvanced", "Show All Advanced Details"), LOCTEXT("ShowAllAdvanced_ToolTip", "Shows all advanced detail sections in each category"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &SDetailsView::OnShowAllAdvancedClicked ), FCanExecuteAction(), FIsActionChecked::CreateSP( this, &SDetailsView::IsShowAllAdvancedChecked ) ), NAME_None, EUserInterfaceActionType::ToggleButton ); DetailViewOptions.AddMenuEntry( LOCTEXT("ShowAllChildrenIfCategoryMatches", "Show Child On Category Match"), LOCTEXT("ShowAllChildrenIfCategoryMatches_ToolTip", "Shows children if their category matches the search criteria"), FSlateIcon(), FUIAction( FExecuteAction::CreateSP( this, &SDetailsView::OnShowAllChildrenIfCategoryMatchesClicked ), FCanExecuteAction(), FIsActionChecked::CreateSP( this, &SDetailsView::IsShowAllChildrenIfCategoryMatchesChecked ) ), NAME_None, EUserInterfaceActionType::ToggleButton ); DetailViewOptions.AddMenuEntry( LOCTEXT("CollapseAll", "Collapse All Categories"), LOCTEXT("CollapseAll_ToolTip", "Collapses all root level categories"), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(this, &SDetailsView::SetRootExpansionStates, /*bExpanded=*/false, /*bRecurse=*/false ))); DetailViewOptions.AddMenuEntry( LOCTEXT("ExpandAll", "Expand All Categories"), LOCTEXT("ExpandAll_ToolTip", "Expands all root level categories"), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(this, &SDetailsView::SetRootExpansionStates, /*bExpanded=*/true, /*bRecurse=*/false ))); FilterRow = SNew( SHorizontalBox ) .Visibility( this, &SDetailsView::GetFilterBoxVisibility ) +SHorizontalBox::Slot() .FillWidth( 1 ) .VAlign( VAlign_Center ) [ // Create the search box SAssignNew( SearchBox, SSearchBox ) .OnTextChanged( this, &SDetailsView::OnFilterTextChanged ) .AddMetaData<FTagMetaData>(TEXT("Details.Search")) ] +SHorizontalBox::Slot() .Padding( 4.0f, 0.0f, 0.0f, 0.0f ) .AutoWidth() [ // Create the search box SNew( SButton ) .OnClicked( this, &SDetailsView::OnOpenRawPropertyEditorClicked ) .IsEnabled( this, &SDetailsView::IsPropertyEditingEnabled ) .ToolTipText( LOCTEXT("RawPropertyEditorButtonLabel", "Open Selection in Property Matrix") ) [ SNew( SImage ) .Image( FEditorStyle::GetBrush("DetailsView.EditRawProperties") ) ] ]; if (DetailsViewArgs.bShowOptions) { FilterRow->AddSlot() .HAlign(HAlign_Right) .AutoWidth() [ SNew( SComboButton ) .ContentPadding(0) .ForegroundColor( FSlateColor::UseForeground() ) .ButtonStyle( FEditorStyle::Get(), "ToggleButton" ) .AddMetaData<FTagMetaData>(FTagMetaData(TEXT("ViewOptions"))) .MenuContent() [ DetailViewOptions.MakeWidget() ] .ButtonContent() [ SNew(SImage) .Image( FEditorStyle::GetBrush("GenericViewButton") ) ] ]; } // Create the name area which does not change when selection changes SAssignNew(NameArea, SDetailNameArea, &SelectedObjects) // the name area is only for actors .Visibility(this, &SDetailsView::GetActorNameAreaVisibility) .OnLockButtonClicked(this, &SDetailsView::OnLockButtonClicked) .IsLocked(this, &SDetailsView::IsLocked) .ShowLockButton(DetailsViewArgs.bLockable) .ShowActorLabel(DetailsViewArgs.bShowActorLabel) // only show the selection tip if we're not selecting objects .SelectionTip(!DetailsViewArgs.bHideSelectionTip); TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox); if( !DetailsViewArgs.bCustomNameAreaLocation ) { VerticalBox->AddSlot() .AutoHeight() .Padding(0.0f, 0.0f, 0.0f, 4.0f) [ NameArea.ToSharedRef() ]; } if( !DetailsViewArgs.bCustomFilterAreaLocation ) { VerticalBox->AddSlot() .AutoHeight() .Padding(0.0f, 0.0f, 0.0f, 2.0f) [ FilterRow.ToSharedRef() ]; } VerticalBox->AddSlot() .FillHeight(1) .Padding(0) [ SNew(SOverlay) + SOverlay::Slot() [ ConstructTreeView(ExternalScrollbar) ] + SOverlay::Slot() .HAlign(HAlign_Right) [ SNew(SBox) .WidthOverride(16.0f) [ ExternalScrollbar ] ] ]; ChildSlot [ VerticalBox ]; }
/** * Fills the Blueprint menu with extra options */ void FillBlueprintOptions(FMenuBuilder& MenuBuilder, TArray<AActor*> SelectedActors) { // Gather Blueprint classes for this actor TArray< FMenuBlueprintClass > BlueprintClasses; GatherBlueprintsForActors( SelectedActors, BlueprintClasses ); MenuBuilder.BeginSection("ActorBlueprint", LOCTEXT("BlueprintsHeading", "Blueprints") ); // Adds the "Create Blueprint..." menu option if valid. { int NumBlueprintableActors = 0; bool IsBlueprintBased = BlueprintClasses.Num() > 1; if(!BlueprintClasses.Num()) { for(auto It(SelectedActors.CreateIterator());It;++It) { AActor* Actor = *It; if( FKismetEditorUtilities::CanCreateBlueprintOfClass(Actor->GetClass())) { NumBlueprintableActors++; } } } const bool bCanHarvestComponentsForBlueprint = (!IsBlueprintBased && (NumBlueprintableActors > 0)); if(bCanHarvestComponentsForBlueprint) { AActor* ActorOverride = nullptr; FUIAction CreateBlueprintAction( FExecuteAction::CreateStatic( &FCreateBlueprintFromActorDialog::OpenDialog, true, ActorOverride ) ); MenuBuilder.AddMenuEntry(LOCTEXT("CreateBlueprint", "Create Blueprint..."), LOCTEXT("CreateBlueprint_Tooltip", "Harvest Components from Selected Actors and create Blueprint"), FSlateIcon(FEditorStyle::GetStyleSetName(), "Kismet.HarvestBlueprintFromActors"), CreateBlueprintAction); } } // Check to see if we have any classes with functions to display if( BlueprintClasses.Num() > 0 ) { { UBlueprint* FirstBlueprint = Cast<UBlueprint>(BlueprintClasses[0].Blueprint.Get()); // Determine if the selected objects that have blueprints are all of the same class, and if they are all up to date bool bAllAreSameType = true; bool bAreAnyNotUpToDate = false; for (int32 ClassIndex = 0; ClassIndex < BlueprintClasses.Num(); ++ClassIndex) { UBlueprint* CurrentBlueprint = Cast<UBlueprint>(BlueprintClasses[ClassIndex].Blueprint.Get()); bAllAreSameType = bAllAreSameType && (CurrentBlueprint == FirstBlueprint); if (CurrentBlueprint != NULL) { bAreAnyNotUpToDate |= !CurrentBlueprint->IsUpToDate(); } } // For a single selected class, we show a top level item (saves 2 clicks); otherwise we show the full hierarchy if (bAllAreSameType && (FirstBlueprint != NULL)) { // Shortcut to edit the blueprint directly, saves two clicks FUIAction UIAction; UIAction.ExecuteAction.BindStatic( &EditKismetCodeFor, /*Blueprint=*/ TWeakObjectPtr<UBlueprint>(FirstBlueprint) ); const FText Label = LOCTEXT("EditBlueprint", "Edit Blueprint"); const FText Description = FText::Format( LOCTEXT("EditBlueprint_ToolTip", "Opens {0} in the Blueprint editor"), FText::FromString( FirstBlueprint->GetName() ) ); MenuBuilder.AddMenuEntry( Label, Description, FSlateIcon(), UIAction ); } else { // More than one type of blueprint is selected, so add a sub-menu for "Edit Kismet Code" MenuBuilder.AddSubMenu( LOCTEXT("EditBlueprintSubMenu", "Edit Blueprint"), LOCTEXT("EditBlueprintSubMenu_ToolTip", "Shows Blueprints that can be opened for editing"), FNewMenuDelegate::CreateStatic( &FillEditCodeMenu, BlueprintClasses ) ); } // For any that aren't up to date, we offer a compile blueprints button if (bAreAnyNotUpToDate) { // Shortcut to edit the blueprint directly, saves two clicks FUIAction UIAction; UIAction.ExecuteAction.BindStatic(&RecompileOutOfDateKismetForSelection); const FText Label = LOCTEXT("CompileOutOfDateBPs", "Compile Out-of-Date Blueprints"); const FText Description = LOCTEXT("CompileOutOfDateBPs_ToolTip", "Compiles out-of-date blueprints for selected actors"); MenuBuilder.AddMenuEntry( Label, Description, FSlateIcon(), UIAction ); } } } MenuBuilder.EndSection(); }
static void FillProjectMenuItems( FMenuBuilder& MenuBuilder ) { MenuBuilder.BeginSection( "FileProject", LOCTEXT("ProjectHeading", "Project") ); { MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().NewProject ); MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().OpenProject ); const bool bUseShortIDEName = true; FText ShortIDEName = FSourceCodeNavigation::GetSuggestedSourceCodeIDE(bUseShortIDEName); MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().AddCodeToProject, NAME_None, TAttribute<FText>(), FText::Format(LOCTEXT("AddCodeToProjectTooltip", "Adds C++ code to the project. The code can only be compiled if you have {0} installed."), ShortIDEName) ); MenuBuilder.AddSubMenu( LOCTEXT("PackageProjectSubMenuLabel", "Package Project"), LOCTEXT("PackageProjectSubMenuToolTip", "Compile, cook and package your project and its content for distribution."), FNewMenuDelegate::CreateStatic( &FPackageProjectMenu::MakeMenu ), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "MainFrame.PackageProject") ); /* MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().LocalizeProject, NAME_None, TAttribute<FText>(), LOCTEXT("LocalizeProjectToolTip", "Gather text from your project and import/export translations.") ); */ /* MenuBuilder.AddSubMenu( LOCTEXT("CookProjectSubMenuLabel", "Cook Project"), LOCTEXT("CookProjectSubMenuToolTip", "Cook your project content for debugging"), FNewMenuDelegate::CreateStatic( &FCookContentMenu::MakeMenu ), false, FSlateIcon() ); */ FString SolutionPath; if(FDesktopPlatformModule::Get()->GetSolutionPath(SolutionPath)) { MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().RefreshCodeProject, NAME_None, FText::Format(LOCTEXT("RefreshCodeProjectLabel", "Refresh {0} Project"), ShortIDEName), FText::Format(LOCTEXT("RefreshCodeProjectTooltip", "Refreshes your C++ code project in {0}."), ShortIDEName) ); MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().OpenIDE, NAME_None, FText::Format(LOCTEXT("OpenIDELabel", "Open {0}"), ShortIDEName), FText::Format(LOCTEXT("OpenIDETooltip", "Opens your C++ code in {0}."), ShortIDEName) ); } else { MenuBuilder.AddMenuEntry( FMainFrameCommands::Get().RefreshCodeProject, NAME_None, FText::Format(LOCTEXT("GenerateCodeProjectLabel", "Generate {0} Project"), ShortIDEName), FText::Format(LOCTEXT("GenerateCodeProjectTooltip", "Generates your C++ code project in {0}."), ShortIDEName) ); } // @hack GDC: this should be moved somewhere else and be less hacky ITargetPlatform* RunningTargetPlatform = GetTargetPlatformManager()->GetRunningTargetPlatform(); if (RunningTargetPlatform != nullptr) { const FName CookedPlatformName = *(RunningTargetPlatform->PlatformName() + TEXT("NoEditor")); const FText CookedPlatformText = FText::FromString(RunningTargetPlatform->PlatformName()); FUIAction Action( FExecuteAction::CreateStatic(&FMainFrameActionCallbacks::CookContent, CookedPlatformName), FCanExecuteAction::CreateStatic(&FMainFrameActionCallbacks::CookContentCanExecute, CookedPlatformName) ); MenuBuilder.AddMenuEntry( FText::Format(LOCTEXT("CookContentForPlatform", "Cook Content for {0}"), CookedPlatformText), FText::Format(LOCTEXT("CookContentForPlatformTooltip", "Cook your game content for debugging on the {0} platform"), CookedPlatformText), FSlateIcon(), Action ); } } MenuBuilder.EndSection(); }
TSharedRef< SWidget > FLevelEditorToolBar::GenerateOpenBlueprintMenuContent( TSharedRef<FUICommandList> InCommandList, TWeakPtr< SLevelEditor > InLevelEditor ) { #define LOCTEXT_NAMESPACE "LevelToolBarViewMenu" struct FBlueprintMenus { /** Generates a sub-level Blueprints sub-menu */ static void MakeSubLevelsMenu(FMenuBuilder& InMenuBuilder, TWeakPtr< SLevelEditor > InLvlEditor) { FSlateIcon EditBP(FEditorStyle::Get().GetStyleSetName(), TEXT("LevelEditor.OpenLevelBlueprint")); InMenuBuilder.BeginSection(NAME_None, LOCTEXT("SubLevelsHeading", "Sub-Level Blueprints")); { UWorld* World = InLvlEditor.Pin()->GetWorld(); for (int32 iLevel = 0; iLevel < World->GetNumLevels(); iLevel++) { ULevel* Level = World->GetLevel(iLevel); if (Level != NULL && Level->GetOutermost() != NULL) { if (!Level->IsPersistentLevel()) { FUIAction UIAction ( FExecuteAction::CreateStatic(&FLevelEditorToolBar::OnOpenSubLevelBlueprint, Level) ); FText DisplayName = FText::Format(LOCTEXT("SubLevelBlueprintItem", "Edit {LevelName}"), FText::FromString(FPaths::GetCleanFilename(Level->GetOutermost()->GetName()))); InMenuBuilder.AddMenuEntry(DisplayName, FText::GetEmpty(), EditBP, UIAction); } } } } InMenuBuilder.EndSection(); } /** Handle BP being selected from popup picker */ static void OnBPSelected(const class FAssetData& AssetData) { UBlueprint* SelectedBP = Cast<UBlueprint>(AssetData.GetAsset()); if(SelectedBP) { FAssetEditorManager::Get().OpenEditorForAsset(SelectedBP); } } /** Generates 'eopn blueprint' sub-menu */ static void MakeOpenClassBPMenu(FMenuBuilder& InMenuBuilder) { FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser")); // Configure filter for asset picker FAssetPickerConfig Config; Config.Filter.ClassNames.Add(UBlueprint::StaticClass()->GetFName()); Config.InitialAssetViewType = EAssetViewType::List; Config.ThumbnailScale = 0; // make thumbnails as small as possible Config.OnAssetSelected = FOnAssetSelected::CreateStatic(&FBlueprintMenus::OnBPSelected); Config.bAllowDragging = false; // Don't show stuff in Engine Config.Filter.PackagePaths.Add("/Game"); Config.Filter.bRecursivePaths = true; TSharedRef<SWidget> Widget = SNew(SBox) .WidthOverride(300.f) .HeightOverride(300.f) [ ContentBrowserModule.Get().CreateAssetPicker(Config) ]; InMenuBuilder.BeginSection(NAME_None, LOCTEXT("BrowseHeader", "Browse")); { InMenuBuilder.AddWidget(Widget, FText::GetEmpty()); } InMenuBuilder.EndSection(); } }; const bool bShouldCloseWindowAfterMenuSelection = true; FMenuBuilder MenuBuilder( bShouldCloseWindowAfterMenuSelection, InCommandList ); MenuBuilder.BeginSection(NAME_None, LOCTEXT("LevelScriptBlueprints", "Level Blueprints")); { MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().OpenLevelBlueprint ); // If there are any sub-levels, display the sub-menu. A single level means there is only the persistent level UWorld* World = InLevelEditor.Pin()->GetWorld(); if(World->GetNumLevels() > 1) { MenuBuilder.AddSubMenu( LOCTEXT( "SubLevelsSubMenu", "Sub-Levels" ), LOCTEXT( "SubLevelsSubMenu_ToolTip", "Shows available sub-level Blueprints that can be edited." ), FNewMenuDelegate::CreateStatic( &FBlueprintMenus::MakeSubLevelsMenu, InLevelEditor ), FUIAction(), NAME_None, EUserInterfaceActionType::Button, false, FSlateIcon(FEditorStyle::Get().GetStyleSetName(), TEXT("LevelEditor.OpenLevelBlueprint")) ); } } MenuBuilder.EndSection(); MenuBuilder.BeginSection(NAME_None, LOCTEXT("GameBlueprints", "Game Blueprints")); { FSlateIcon EditBPIcon(FEditorStyle::Get().GetStyleSetName(), TEXT("PropertyWindow.Button_Edit")); FSlateIcon NewBPIcon(FEditorStyle::Get().GetStyleSetName(), TEXT("PropertyWindow.Button_AddToArray")); // Game Mode TAttribute<FText>::FGetter DynamicGameModeGetter; DynamicGameModeGetter.BindStatic(&FLevelEditorToolBar::GetOpenGameModeBlueprintLabel, InLevelEditor); TAttribute<FText> DynamicGameModeLabel = TAttribute<FText>::Create(DynamicGameModeGetter); TAttribute<FText>::FGetter DynamicGameModeGetter_Tooltip; DynamicGameModeGetter_Tooltip.BindStatic(&FLevelEditorToolBar::GetOpenGameModeBlueprintTooltip, InLevelEditor); TAttribute<FText> DynamicGameModeTooltip = TAttribute<FText>::Create(DynamicGameModeGetter_Tooltip); MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().OpenGameModeBlueprint, NAME_None, DynamicGameModeLabel, DynamicGameModeTooltip, IsValidGameModeBlueprint(InLevelEditor)? EditBPIcon : NewBPIcon ); // Game State TAttribute<FText>::FGetter DynamicGameStateGetter; DynamicGameStateGetter.BindStatic(&FLevelEditorToolBar::GetOpenGameStateBlueprintLabel, InLevelEditor); TAttribute<FText> DynamicGameStateLabel = TAttribute<FText>::Create(DynamicGameStateGetter); TAttribute<FText>::FGetter DynamicGameStateGetter_Tooltip; DynamicGameStateGetter_Tooltip.BindStatic(&FLevelEditorToolBar::GetOpenGameStateBlueprintTooltip, InLevelEditor); TAttribute<FText> DynamicGameStateTooltip = TAttribute<FText>::Create(DynamicGameStateGetter_Tooltip); MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().OpenGameStateBlueprint, NAME_None, DynamicGameStateLabel, DynamicGameStateTooltip, IsValidGameStateBlueprint(InLevelEditor)? EditBPIcon : NewBPIcon ); // Pawn TAttribute<FText>::FGetter DynamicDefaultPawnGetter; DynamicDefaultPawnGetter.BindStatic(&FLevelEditorToolBar::GetOpenPawnBlueprintLabel, InLevelEditor); TAttribute<FText> DynamicDefaultPawnLabel = TAttribute<FText>::Create(DynamicDefaultPawnGetter); TAttribute<FText>::FGetter DynamicDefaultPawnGetter_Tooltip; DynamicDefaultPawnGetter_Tooltip.BindStatic(&FLevelEditorToolBar::GetOpenPawnBlueprintTooltip, InLevelEditor); TAttribute<FText> DynamicDefaultPawnTooltip = TAttribute<FText>::Create(DynamicDefaultPawnGetter_Tooltip); MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().OpenDefaultPawnBlueprint, NAME_None, DynamicDefaultPawnLabel, DynamicDefaultPawnTooltip, IsValidPawnBlueprint(InLevelEditor)? EditBPIcon : NewBPIcon ); // HUD TAttribute<FText>::FGetter DynamicHUDGetter; DynamicHUDGetter.BindStatic(&FLevelEditorToolBar::GetOpenHUDBlueprintLabel, InLevelEditor); TAttribute<FText> DynamicHUDLabel = TAttribute<FText>::Create(DynamicHUDGetter); TAttribute<FText>::FGetter DynamicHUDGetter_Tooltip; DynamicHUDGetter_Tooltip.BindStatic(&FLevelEditorToolBar::GetOpenHUDBlueprintTooltip, InLevelEditor); TAttribute<FText> DynamicHUDTooltip = TAttribute<FText>::Create(DynamicHUDGetter_Tooltip); MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().OpenHUDBlueprint, NAME_None, DynamicHUDLabel, DynamicHUDTooltip, IsValidHUDBlueprint(InLevelEditor)? EditBPIcon : NewBPIcon ); // Player Controller TAttribute<FText>::FGetter DynamicPlayerControllerGetter; DynamicPlayerControllerGetter.BindStatic(&FLevelEditorToolBar::GetOpenPlayerControllerBlueprintLabel, InLevelEditor); TAttribute<FText> DynamicPlayerControllerLabel = TAttribute<FText>::Create(DynamicPlayerControllerGetter); TAttribute<FText>::FGetter DynamicPlayerControllerGetter_Tooltip; DynamicPlayerControllerGetter_Tooltip.BindStatic(&FLevelEditorToolBar::GetOpenPlayerControllerBlueprintTooltip, InLevelEditor); TAttribute<FText> DynamicPlayerControllerTooltip = TAttribute<FText>::Create(DynamicPlayerControllerGetter_Tooltip); MenuBuilder.AddMenuEntry( FLevelEditorCommands::Get().OpenPlayerControllerBlueprint, NAME_None, DynamicPlayerControllerLabel, DynamicPlayerControllerTooltip, IsValidPlayerControllerBlueprint(InLevelEditor)? EditBPIcon : NewBPIcon ); } MenuBuilder.EndSection(); MenuBuilder.BeginSection(NAME_None, LOCTEXT("ClassBlueprints", "Class Blueprints")); { // New Class Blueprint... MenuBuilder.AddMenuEntry(FLevelEditorCommands::Get().CreateClassBlueprint, NAME_None, LOCTEXT("NewClassBlueprint", "New Class Blueprint...")); // Open Class Blueprint... FSlateIcon OpenBPIcon(FEditorStyle::GetStyleSetName(), "LevelEditor.OpenClassBlueprint"); MenuBuilder.AddSubMenu( LOCTEXT("OpenClassBlueprintSubMenu", "Open Class Blueprint..."), LOCTEXT("OpenClassBlueprintSubMenu_ToolTip", "Open an existing Class Blueprint in this project"), FNewMenuDelegate::CreateStatic(&FBlueprintMenus::MakeOpenClassBPMenu), false, OpenBPIcon ); } MenuBuilder.EndSection(); #undef LOCTEXT_NAMESPACE return MenuBuilder.MakeWidget(); }