bool UInterpTrackAkAudioEventHelper::PreCreateKeyframe(UInterpTrack * Track, float KeyTime) const
{
bool bResult = false;
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_InterpEdit);
check(Mode != NULL);
IMatineeBase* InterpEd = Mode->InterpEd;
check(InterpEd != NULL);
UAkAudioEvent* SelectedEvent = GEditor->GetSelectedObjects()->GetTop<UAkAudioEvent>();
TSharedRef<SWidget> PropWidget = SNew(SMatineeAkEventKeyFrameAdder)
.SelectedAkEvent(SelectedEvent)
.OnAkEventSet(FOnAkEventSet::CreateUObject(this,&UInterpTrackAkAudioEventHelper::OnAkEventSet, InterpEd, Track));
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if (Parent.IsValid())
{
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
PropWidget,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::None)
);
}
return bResult;
}
/** Handle a click on the specified editor viewport client */
bool FComponentVisualizerManager::HandleClick(FEditorViewportClient* InViewportClient, HHitProxy* HitProxy, const FViewportClick& Click)
{
bool bHandled = HandleProxyForComponentVis(InViewportClient, HitProxy, Click);
if (bHandled && Click.GetKey() == EKeys::RightMouseButton)
{
TSharedPtr<SWidget> MenuWidget = GenerateContextMenuForComponentVis();
if (MenuWidget.IsValid())
{
TSharedPtr<SEditorViewport> ViewportWidget = InViewportClient->GetEditorViewportWidget();
if (ViewportWidget.IsValid())
{
FSlateApplication::Get().PushMenu(
ViewportWidget.ToSharedRef(),
FWidgetPath(),
MenuWidget.ToSharedRef(),
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
return true;
}
}
}
return false;
}
void UJavascriptEditorLibrary::OpenPopupWindow(UWidget* Widget, const FVector2D& PopupDesiredSize, const FText& HeadingText)
{
// Create the contents of the popup
TSharedRef<SWidget> ActualWidget = Widget->TakeWidget();
// Wrap the picker widget in a multibox-style menu body
FMenuBuilder MenuBuilder(/*BShouldCloseAfterSelection=*/ false, /*CommandList=*/ nullptr);
MenuBuilder.BeginSection("OpenPopupWindow", HeadingText);
MenuBuilder.AddWidget(ActualWidget, FText::GetEmpty(), /*bNoIndent=*/ true);
MenuBuilder.EndSection();
auto WindowContents = MenuBuilder.MakeWidget();
// Determine where the pop-up should open
TSharedPtr<SWindow> ParentWindow = FSlateApplication::Get().GetActiveTopLevelWindow();
FVector2D WindowPosition = FSlateApplication::Get().GetCursorPos();
if (!ParentWindow.IsValid())
{
return;
}
if (ParentWindow.IsValid())
{
FSlateRect ParentMonitorRect = ParentWindow->GetFullScreenInfo();
const FVector2D MonitorCenter((ParentMonitorRect.Right + ParentMonitorRect.Left) * 0.5f, (ParentMonitorRect.Top + ParentMonitorRect.Bottom) * 0.5f);
WindowPosition = MonitorCenter - PopupDesiredSize * 0.5f;
// Open the pop-up
FPopupTransitionEffect TransitionEffect(FPopupTransitionEffect::None);
auto Menu = FSlateApplication::Get().PushMenu(ParentWindow.ToSharedRef(), FWidgetPath(), WindowContents, WindowPosition, TransitionEffect, /*bFocusImmediately=*/ true);
}
}
END_SLATE_FUNCTION_BUILD_OPTIMIZATION
/** RuleShare = true if we are sharing the rules of this transition (else we are implied to be sharing the crossfade settings) */
FReply FAnimTransitionNodeDetails::OnPromoteToSharedClick(bool RuleShare)
{
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
// Show dialog to enter new track name
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label( LOCTEXT("PromoteAnimTransitionNodeToSharedLabel", "Shared Transition Name") )
.OnTextCommitted(this, &FAnimTransitionNodeDetails::PromoteToShared, RuleShare);
// Show dialog to enter new event name
FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect( FPopupTransitionEffect::TypeInPopup )
);
TextEntryWidget = TextEntry;
}
return FReply::Handled();
}
bool UMatineeTrackEventHelper::PreCreateKeyframe( UInterpTrack *Track, float KeyTime ) const
{
KeyframeAddDataName = NAME_None;
// Prompt user for name of new event.
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
check(Mode->InterpEd != NULL);
TSharedRef<STextEntryPopup> TextEntryPopup =
SNew(STextEntryPopup)
.Label(NSLOCTEXT("Matinee.Popups", "NewEventName", "New Event Name"))
.DefaultText(FText::FromString(TEXT("Event")))
.OnTextCommitted_UObject(this, &UMatineeTrackEventHelper::OnAddKeyTextEntry, (IMatineeBase*)Mode->InterpEd, Track)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false)
.MaxWidth(1024.0f)
;
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
return false;
}
void SColorGradientEditor::OpenGradientStopColorPicker()
{
TArray<FRichCurveEditInfo> Curves = CurveOwner->GetCurves();
if( SelectedStop.IsValidAlphaMark( Curves ) )
{
// Show a slider to change the alpha value
TSharedRef<SWidget> AlphaSlider =
SNew( SBorder )
.BorderImage( FEditorStyle::GetBrush("Menu.Background") )
[
SNew( SVerticalBox )
+ SVerticalBox::Slot()
[
SNew( STextBlock )
.Text( LOCTEXT("AlphaLabel","Opacity") )
.TextStyle( FEditorStyle::Get(), "Menu.Heading" )
]
+ SVerticalBox::Slot()
.Padding( 3.0f, 2.0f, 3.0f, 5.0f )
.AutoHeight()
[
SNew( SBox )
.WidthOverride( 100.0f )
[
SNew( SSpinBox<float> )
.MinSliderValue(0.0f)
.MaxSliderValue(1.0f)
.MinValue(-FLT_MAX)
.MaxValue(FLT_MAX)
.Value( SelectedStop.GetColor( *CurveOwner ).A )
.OnBeginSliderMovement( this, &SColorGradientEditor::OnBeginChangeAlphaValue )
.OnEndSliderMovement( this, &SColorGradientEditor::OnEndChangeAlphaValue )
.OnValueChanged( this, &SColorGradientEditor::OnAlphaValueChanged )
.OnValueCommitted( this, &SColorGradientEditor::OnAlphaValueCommitted )
]
]
];
FSlateApplication::Get().PushMenu( SharedThis( this ), FWidgetPath(), AlphaSlider, ContextMenuPosition, FPopupTransitionEffect::TypeInPopup );
}
else
{
// Open a color picker
FColorPickerArgs ColorPickerArgs;
ColorPickerArgs.bOnlyRefreshOnMouseUp = false;
ColorPickerArgs.bIsModal = false;
ColorPickerArgs.ParentWidget = SharedThis( this );
ColorPickerArgs.bUseAlpha = false;
ColorPickerArgs.InitialColorOverride = SelectedStop.GetColor( *CurveOwner );
ColorPickerArgs.OnColorCommitted = FOnLinearColorValueChanged::CreateSP( this, &SColorGradientEditor::OnSelectedStopColorChanged );
ColorPickerArgs.OnColorPickerCancelled = FOnColorPickerCancelled::CreateSP( this, &SColorGradientEditor::OnCancelSelectedStopColorChange );
OpenColorPicker( ColorPickerArgs );
}
}
FWidgetPath FWidgetPath::GetPathDownTo( TSharedRef<const SWidget> MarkerWidget ) const
{
FArrangedChildren ClippedPath(EVisibility::Visible);
bool bCopiedMarker = false;
for( int32 WidgetIndex = 0; !bCopiedMarker && WidgetIndex < Widgets.Num(); ++WidgetIndex )
{
ClippedPath.AddWidget( Widgets[WidgetIndex] );
bCopiedMarker = (Widgets[WidgetIndex].Widget == MarkerWidget);
}
if ( bCopiedMarker )
{
// We found the MarkerWidget and copied the path down to (and including) it.
return FWidgetPath( TopLevelWindow, ClippedPath );
}
else
{
// The MarkerWidget was not in the widget path. We failed.
return FWidgetPath( nullptr, FArrangedChildren(EVisibility::Visible) );
}
}
void SBlendProfilePicker::OnCreateNewProfile()
{
TSharedRef<STextEntryPopup> TextEntry = SNew(STextEntryPopup)
.Label(LOCTEXT("NewProfileName", "Profile Name"))
.OnTextCommitted(this, &SBlendProfilePicker::OnCreateNewProfileComitted);
FSlateApplication::Get().PushMenu(
AsShared(),
FWidgetPath(),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup));
}
void SScrubWidget::OnShowPopupOfAppendAnimation(bool bBegin)
{
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(LOCTEXT("AppendAnim_AskNumFrames", "Number of Frames to Append"))
.OnTextCommitted(this, &SScrubWidget::OnSequenceAppendedCalled, bBegin);
// Show dialog to enter new track name
FSlateApplication::Get().PushMenu(
SharedThis(this),
FWidgetPath(),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
void FPhATEdPreviewViewportClient::OpenConstraintMenu()
{
TSharedPtr<SWidget> MenuWidget = PhATPtr.Pin()->BuildMenuWidgetConstraint();
TSharedPtr< SPhATPreviewViewport > ParentWidget = PhATPtr.Pin()->GetPreviewViewportWidget();
if ( MenuWidget.IsValid() && ParentWidget.IsValid() )
{
const FVector2D MouseCursorLocation = FSlateApplication::Get().GetCursorPos();
FSlateApplication::Get().PushMenu(
ParentWidget.ToSharedRef(),
FWidgetPath(),
MenuWidget.ToSharedRef(),
MouseCursorLocation,
FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu)
);
}
}
bool UMatineeTrackDirectorHelper::PreCreateKeyframe( UInterpTrack *Track, float KeyTime ) const
{
// If adding a cut, bring up combo to let user choose group to cut to.
KeyframeAddDataName = NAME_None;
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL && Mode->InterpEd != NULL);
if ( (Mode != NULL) && (Mode->InterpEd != NULL) )
{
// Make array of group names
TArray<FString> GroupNames;
for ( UInterpGroup* InterpGroup : Mode->InterpEd->GetInterpData()->InterpGroups )
{
if ( !InterpGroup->bIsFolder )
{
GroupNames.Add(InterpGroup->GroupName.ToString());
}
}
TSharedRef<STextComboPopup> TextEntryPopup =
SNew(STextComboPopup)
.Label(NSLOCTEXT("Matinee.Popups", "NewCut", "Cut to Group..."))
.TextOptions(GroupNames)
.OnTextChosen_UObject(this, &UMatineeTrackDirectorHelper::OnAddKeyTextEntry, Mode->InterpEd, Track);
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
}
return false;
}
FReply SFbxSSceneBaseMeshListView::OnCreateOverrideOptions()
{
//pop a dialog to ask the option name, if the user cancel the name will be "Option #"
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(LOCTEXT("FbxOptionWindow_SM_CreateOverrideAskName", "Override Option name"))
.DefaultText(FText::FromString(TEXT("Options")))
.OnTextCommitted(this, &SFbxSSceneBaseMeshListView::OnCreateOverrideOptionsWithName);
FSlateApplication& SlateApp = FSlateApplication::Get();
SlateApp.PushMenu(
AsShared(),
FWidgetPath(),
TextEntry,
SlateApp.GetCursorPos(),
FPopupTransitionEffect::TypeInPopup
);
return FReply::Handled();
}
bool UMatineeTrackToggleHelper::PreCreateKeyframe( UInterpTrack *Track, float KeyTime ) const
{
bool bResult = false;
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
IMatineeBase* InterpEd = Mode->InterpEd;
check(InterpEd != NULL);
TArray<FString> PropStrings;
PropStrings.AddZeroed( 3 );
PropStrings[0] = TEXT("Trigger");
PropStrings[1] = TEXT("On");
PropStrings[2] = TEXT("Off");
TSharedRef<STextComboPopup> TextEntryPopup =
SNew(STextComboPopup)
.Label(NSLOCTEXT("Matinee.Popups", "ToggleAction", "Toggle Action"))
.TextOptions(PropStrings)
.OnTextChosen_UObject(this, &UMatineeTrackToggleHelper::OnAddKeyTextEntry, InterpEd, Track)
;
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
return bResult;
}
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));
}
}
FReply STutorialButton::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
{
const bool bInShouldCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder(bInShouldCloseWindowAfterMenuSelection, nullptr);
if(ShouldShowAlert())
{
MenuBuilder.AddMenuEntry(
LOCTEXT("DismissReminder", "Don't Remind Me Again"),
LOCTEXT("DismissReminderTooltip", "Selecting this option will prevent the tutorial blip from being displayed again, even if you choose not to complete the tutorial."),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(this, &STutorialButton::DismissAlert))
);
MenuBuilder.AddMenuEntry(
LOCTEXT("DismissAllReminders", "Dismiss All Tutorial Reminders"),
LOCTEXT("DismissAllRemindersTooltip", "Selecting this option will prevent all tutorial blips from being displayed."),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(this, &STutorialButton::DismissAllAlerts))
);
MenuBuilder.AddMenuSeparator();
}
if(bTutorialAvailable)
{
MenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("LaunchTutorialPattern", "Start Tutorial: {0}"), TutorialTitle),
FText::Format(LOCTEXT("TutorialLaunchToolTip", "Click to begin the '{0}' tutorial"), TutorialTitle),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(this, &STutorialButton::LaunchTutorial))
);
}
MenuBuilder.AddMenuEntry(
LOCTEXT("LaunchBrowser", "Show Available Tutorials"),
LOCTEXT("LaunchBrowserTooltip", "Display the tutorials browser"),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(this, &STutorialButton::LaunchBrowser))
);
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(SharedThis(this), WidgetPath, MenuBuilder.MakeWidget(), FSlateApplication::Get().GetCursorPos(), FPopupTransitionEffect::ContextMenu);
}
return FReply::Handled();
}
/**
* See SWidget::OnMouseButtonDown.
*
* @param MyGeometry The Geometry of the widget receiving the event
* @param MouseEvent Information about the input event
*
* @return Whether the event was handled along with possible requests for the system to take action.
*/
FReply SCheckBox::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
bIsPressed = true;
if( ClickMethod == EButtonClickMethod::MouseDown )
{
ToggleCheckedState();
const ECheckBoxState State = IsCheckboxChecked.Get();
if(State == ECheckBoxState::Checked)
{
PlayCheckedSound();
}
else if(State == ECheckBoxState::Unchecked)
{
PlayUncheckedSound();
}
// Set focus to this button, but don't capture the mouse
return FReply::Handled().SetUserFocus(AsShared(), EFocusCause::Mouse);
}
else
{
// Capture the mouse, and also set focus to this button
return FReply::Handled().CaptureMouse(AsShared()).SetUserFocus(AsShared(), EFocusCause::Mouse);
}
}
else if ( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && OnGetMenuContent.IsBound() )
{
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(
AsShared(),
WidgetPath,
OnGetMenuContent.Execute(),
MouseEvent.GetScreenSpacePosition(),
FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu )
);
return FReply::Handled();
}
else
{
return FReply::Unhandled();
}
}
FReply SSection::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( bDragging && DragOperation.IsValid() )
{
// If dragging tell the operation we are no longer dragging
DragOperation->OnEndDrag(ParentSectionArea);
}
else
{
if( ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton || MouseEvent.GetEffectingButton() == EKeys::RightMouseButton ) && HasMouseCapture() && MyGeometry.IsUnderLocation( MouseEvent.GetScreenSpacePosition() ) )
{
HandleSelection( MyGeometry, MouseEvent );
}
if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && HasMouseCapture() )
{
TSharedPtr<SWidget> MenuContent = OnSummonContextMenu( MyGeometry, MouseEvent );
if (MenuContent.IsValid())
{
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(
AsShared(),
WidgetPath,
MenuContent.ToSharedRef(),
MouseEvent.GetScreenSpacePosition(),
FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu )
);
return FReply::Handled().ReleaseMouseCapture().SetUserFocus(MenuContent.ToSharedRef(), EFocusCause::SetDirectly);
}
}
}
ResetState();
return FReply::Handled().ReleaseMouseCapture();
}
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();
}
FReply FSequencerTimeSliderController::OnMouseButtonUp( SWidget& WidgetOwner, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
bool bHandleLeftMouseButton = MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton && WidgetOwner.HasMouseCapture();
bool bHandleRightMouseButton = MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && WidgetOwner.HasMouseCapture() && TimeSliderArgs.AllowZoom ;
if ( bHandleRightMouseButton )
{
if (!bPanning)
{
// Open a context menu if allowed
if (ContextMenuSupression == 0 && TimeSliderArgs.PlaybackRange.IsSet())
{
FScrubRangeToScreen RangeToScreen( TimeSliderArgs.ViewRange.Get(), MyGeometry.Size );
FVector2D CursorPos = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
float MouseValue = RangeToScreen.LocalXToInput( CursorPos.X );
if (TimeSliderArgs.Settings->GetIsSnapEnabled())
{
MouseValue = TimeSliderArgs.Settings->SnapTimeToInterval(MouseValue);
}
TSharedRef<SWidget> MenuContent = OpenSetPlaybackRangeMenu(MouseValue);
FSlateApplication::Get().PushMenu(
WidgetOwner.AsShared(),
MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath(),
MenuContent,
MouseEvent.GetScreenSpacePosition(),
FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu )
);
return FReply::Handled().SetUserFocus(MenuContent, EFocusCause::SetDirectly).ReleaseMouseCapture();
}
// return unhandled in case our parent wants to use our right mouse button to open a context menu
return FReply::Unhandled().ReleaseMouseCapture();
}
bPanning = false;
return FReply::Handled().ReleaseMouseCapture();
}
else if ( bHandleLeftMouseButton )
{
if (MouseDragType == DRAG_START_RANGE)
{
TimeSliderArgs.OnEndPlaybackRangeDrag.ExecuteIfBound();
}
// Set the end range time?
else if (MouseDragType == DRAG_END_RANGE)
{
TimeSliderArgs.OnEndPlaybackRangeDrag.ExecuteIfBound();
}
else if (MouseDragType == DRAG_SETTING_RANGE)
{
FScrubRangeToScreen RangeToScreen( TimeSliderArgs.ViewRange.Get(), MyGeometry.Size );
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetLastScreenSpacePosition());
float NewValue = RangeToScreen.LocalXToInput(CursorPos.X);
if ( TimeSliderArgs.Settings->GetIsSnapEnabled() )
{
NewValue = TimeSliderArgs.Settings->SnapTimeToInterval(NewValue);
}
float DownValue = MouseDownRange[0];
if ( TimeSliderArgs.Settings->GetIsSnapEnabled() )
{
DownValue = TimeSliderArgs.Settings->SnapTimeToInterval(DownValue);
}
// Zoom in
if (NewValue > DownValue)
{
// push the current value onto the stack
RangeStack.Add(FVector2D(TimeSliderArgs.ViewRange.Get().GetLowerBoundValue(), TimeSliderArgs.ViewRange.Get().GetUpperBoundValue()));
}
// Zoom out
else if (RangeStack.Num())
{
// pop the stack
FVector2D LastRange = RangeStack.Pop();
DownValue = LastRange[0];
NewValue = LastRange[1];
}
TimeSliderArgs.OnViewRangeChanged.ExecuteIfBound(TRange<float>(DownValue, NewValue), EViewRangeInterpolation::Immediate);
if( !TimeSliderArgs.ViewRange.IsBound() )
{
// The output is not bound to a delegate so we'll manage the value ourselves
TimeSliderArgs.ViewRange.Set( TRange<float>( DownValue, NewValue ) );
}
}
else
{
TimeSliderArgs.OnEndScrubberMovement.ExecuteIfBound();
FScrubRangeToScreen RangeToScreen( TimeSliderArgs.ViewRange.Get(), MyGeometry.Size );
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetLastScreenSpacePosition());
float NewValue = RangeToScreen.LocalXToInput(CursorPos.X);
if ( TimeSliderArgs.Settings->GetIsSnapEnabled() && TimeSliderArgs.Settings->GetSnapPlayTimeToInterval() )
{
NewValue = TimeSliderArgs.Settings->SnapTimeToInterval(NewValue);
}
CommitScrubPosition( NewValue, /*bIsScrubbing=*/false );
}
MouseDragType = DRAG_NONE;
return FReply::Handled().ReleaseMouseCapture();
}
return FReply::Unhandled();
}
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(Panel, FWidgetPath(), MenuBuilder.MakeWidget(), ScreenPosition, FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu));
}
return FReply::Handled();
}
FWeakWidgetPath::EPathResolutionResult::Result FWeakWidgetPath::ToWidgetPath( FWidgetPath& WidgetPath, EInterruptedPathHandling::Type InterruptedPathHandling, const FPointerEvent* PointerEvent ) const
{
SCOPE_CYCLE_COUNTER(STAT_ToWidgetPath);
TArray<FWidgetAndPointer> PathWithGeometries;
TArray< TSharedPtr<SWidget> > WidgetPtrs;
// Convert the weak pointers into shared pointers because we are about to do something with this path instead of just observe it.
TSharedPtr<SWindow> TopLevelWindowPtr = Window.Pin();
for( TArray< TWeakPtr<SWidget> >::TConstIterator SomeWeakWidgetPtr( Widgets ); SomeWeakWidgetPtr; ++SomeWeakWidgetPtr )
{
WidgetPtrs.Add( SomeWeakWidgetPtr->Pin() );
}
// The path can get interrupted if some subtree of widgets disappeared, but we still maintain weak references to it.
bool bPathUninterrupted = false;
// For each widget in the path compute the geometry. We are able to do this starting with the top-level window because it knows its own geometry.
if ( TopLevelWindowPtr.IsValid() )
{
bPathUninterrupted = true;
FGeometry ParentGeometry = TopLevelWindowPtr->GetWindowGeometryInScreen();
PathWithGeometries.Add( FWidgetAndPointer(
FArrangedWidget( TopLevelWindowPtr.ToSharedRef(), ParentGeometry ),
// @todo slate: this should be the cursor's virtual position in window space.
TSharedPtr<FVirtualPointerPosition>() ) );
FArrangedChildren ArrangedChildren(EVisibility::Visible, true);
TSharedPtr<FVirtualPointerPosition> VirtualPointerPos;
// For every widget in the vertical slice...
for( int32 WidgetIndex = 0; bPathUninterrupted && WidgetIndex < WidgetPtrs.Num()-1; ++WidgetIndex )
{
TSharedPtr<SWidget> CurWidget = WidgetPtrs[WidgetIndex];
bool bFoundChild = false;
if ( CurWidget.IsValid() )
{
// Arrange the widget's children to find their geometries.
ArrangedChildren.Empty();
CurWidget->ArrangeChildren(ParentGeometry, ArrangedChildren);
// Find the next widget in the path among the arranged children.
for( int32 SearchIndex = 0; !bFoundChild && SearchIndex < ArrangedChildren.Num(); ++SearchIndex )
{
FArrangedWidget& ArrangedWidget = ArrangedChildren[SearchIndex];
if ( ArrangedWidget.Widget == WidgetPtrs[WidgetIndex+1] )
{
if( PointerEvent && !VirtualPointerPos.IsValid() )
{
VirtualPointerPos = CurWidget->TranslateMouseCoordinateFor3DChild( ArrangedWidget.Widget, ParentGeometry, PointerEvent->GetScreenSpacePosition(), PointerEvent->GetLastScreenSpacePosition() );
}
bFoundChild = true;
// Remember the widget, the associated geometry, and the pointer position in a transformed space.
PathWithGeometries.Add( FWidgetAndPointer(ArrangedChildren[SearchIndex], VirtualPointerPos) );
// The next child in the vertical slice will be arranged with respect to its parent's geometry.
ParentGeometry = ArrangedChildren[SearchIndex].Geometry;
}
}
}
bPathUninterrupted = bFoundChild;
if (!bFoundChild && InterruptedPathHandling == EInterruptedPathHandling::ReturnInvalid )
{
return EPathResolutionResult::Truncated;
}
}
}
WidgetPath = FWidgetPath( PathWithGeometries );
return bPathUninterrupted ? EPathResolutionResult::Live : EPathResolutionResult::Truncated;
}
bool UMatineeTrackAnimControlHelper::PreCreateKeyframe( UInterpTrack *Track, float fTime ) const
{
KeyframeAddAnimSequence = NULL;
UInterpTrackAnimControl *AnimTrack = CastChecked<UInterpTrackAnimControl>(Track);
UInterpGroup* Group = CastChecked<UInterpGroup>(Track->GetOuter());
AActor* Actor = GetGroupActor(Track);
if (!Actor)
{
// error message
UE_LOG(LogSlateMatinee, Warning, TEXT("No Actor is selected. Select actor first."));
return false;
}
USkeletalMeshComponent * SkelMeshComp = NULL;
TInlineComponentArray<USkeletalMeshComponent*> SkeletalMeshComponents;
Actor->GetComponents(SkeletalMeshComponents);
for (int32 I=0; I<SkeletalMeshComponents.Num(); ++I)
{
USkeletalMeshComponent * CurSkelMeshComp = SkeletalMeshComponents[I];
// if qualified to play animation, break
if (CurSkelMeshComp->SkeletalMesh && CurSkelMeshComp->SkeletalMesh->Skeleton)
{
SkelMeshComp = CurSkelMeshComp;
break;
}
}
if (!SkelMeshComp)
{
UE_LOG(LogSlateMatinee, Warning, TEXT("SkeletalMeshComponent isn't found in the selected actor or it does not have Mesh/Skeleton set up in order to play animation"));
return false;
}
USkeleton* Skeleton = SkelMeshComp->SkeletalMesh->Skeleton;
if ( Skeleton )
{
// Show the dialog.
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
check(Mode->InterpEd != NULL);
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
FAssetPickerConfig AssetPickerConfig;
AssetPickerConfig.OnAssetSelected = FOnAssetSelected::CreateUObject( this, &UMatineeTrackAnimControlHelper::OnAddKeyTextEntry, Mode->InterpEd, Track );
AssetPickerConfig.bAllowNullSelection = false;
AssetPickerConfig.InitialAssetViewType = EAssetViewType::List;
// Filter config
AssetPickerConfig.Filter.ClassNames.Add(UAnimSequence::StaticClass()->GetFName());
AssetPickerConfig.Filter.TagsAndValues.Add(TEXT("Skeleton"), FAssetData(Skeleton).GetExportTextName());
FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser"));
FMenuBuilder MenuBuilder(true, NULL);
MenuBuilder.BeginSection(NAME_None, LOCTEXT("MatineeAnimPicker", "Browse"));
{
TSharedPtr<SBox> MenuEntry = SNew(SBox)
.WidthOverride(300.0f)
.HeightOverride(300.f)
[
ContentBrowserModule.Get().CreateAssetPicker(AssetPickerConfig)
];
MenuBuilder.AddWidget(MenuEntry.ToSharedRef(), FText::GetEmpty(), true);
}
MenuBuilder.EndSection();
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
MenuBuilder.MakeWidget(),
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
}
else
{
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "NoAnimSeqsFound", "No AnimSequences Found. Make sure to load AnimSequences.") );
}
return false;
}
FReply SAnimationOutlinerTreeNode::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
TSharedPtr<SWidget> MenuContent = DisplayNode->OnSummonContextMenu(MyGeometry, MouseEvent);
if (MenuContent.IsValid())
{
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(
AsShared(),
WidgetPath,
MenuContent.ToSharedRef(),
MouseEvent.GetScreenSpacePosition(),
FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu )
);
return FReply::Handled().SetUserFocus(MenuContent.ToSharedRef(), EFocusCause::SetDirectly);
}
return FReply::Handled();
}
return FReply::Unhandled();
}
void SRealtimeProfilerVisualizer::OnBarGraphContextMenu( TSharedPtr< FVisualizerEvent > Selection, const FPointerEvent& InputEvent )
{
SelectedBarGraph = Selection;
FWidgetPath WidgetPath = InputEvent.GetEventPath() != nullptr ? *InputEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(SharedThis(this), WidgetPath, MakeBarVisualizerContextMenu(), FSlateApplication::Get().GetCursorPos(), FPopupTransitionEffect::ContextMenu);
}
FReply SFlipbookTimeline::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
{
TSharedRef<SWidget> MenuContents = GenerateContextMenu();
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(AsShared(), WidgetPath, MenuContents, MouseEvent.GetScreenSpacePosition(), FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
return FReply::Handled();
}
else
{
return FReply::Unhandled();
}
}
void SColorGradientEditor::OpenGradientStopContextMenu(const FPointerEvent& MouseEvent)
{
const FVector2D& Location = MouseEvent.GetScreenSpacePosition();
FMenuBuilder GradientStopMenu( true, NULL );
FUIAction RemoveStopAction( FExecuteAction::CreateSP( this, &SColorGradientEditor::OnRemoveSelectedGradientStop ) );
{
TSharedPtr<SWidget> WidgetToFocus;
// Set color
if( SelectedStop.IsValidColorMark( CurveOwner->GetCurves() ) )
{
GradientStopMenu.BeginSection( NAME_None, LOCTEXT("ColorMenuSecton", "Color") );
FUIAction SetColorAction( FExecuteAction::CreateSP( this, &SColorGradientEditor::OpenGradientStopColorPicker ) );
GradientStopMenu.AddMenuEntry( LOCTEXT("SetColorMenuItem", "Choose Color..."), LOCTEXT("SetColorMenuItem_ToolTip", "Opens a color picker to change the color of the stop"), FSlateIcon(), SetColorAction );
GradientStopMenu.EndSection();
}
else
{
GradientStopMenu.BeginSection( NAME_None, LOCTEXT("AlphaMenuSection", "Opacity") );
TSharedRef<SWidget> Widget =
SNew( SBox )
.WidthOverride( 100.0f )
[
SNew( SSpinBox<float> )
.MinSliderValue(0.0f)
.MaxSliderValue(1.0f)
.MinValue(-FLT_MAX)
.MaxValue(FLT_MAX)
.Value( SelectedStop.GetColor( *CurveOwner ).A )
.OnBeginSliderMovement( this, &SColorGradientEditor::OnBeginChangeAlphaValue )
.OnEndSliderMovement( this, &SColorGradientEditor::OnEndChangeAlphaValue )
.OnValueChanged( this, &SColorGradientEditor::OnAlphaValueChanged )
.OnValueCommitted( this, &SColorGradientEditor::OnAlphaValueCommitted )
];
GradientStopMenu.AddWidget( Widget, FText::GetEmpty() );
GradientStopMenu.EndSection();
}
// Set time
{
TSharedRef<SEditableTextBox> EditableTextBox =
SNew( SEditableTextBox )
.MinDesiredWidth(50.0f)
.Text( FText::AsNumber( SelectedStop.Time ) )
.OnTextCommitted( this, &SColorGradientEditor::OnSetGradientStopTimeFromPopup )
.SelectAllTextWhenFocused( true )
.ClearKeyboardFocusOnCommit( false )
.SelectAllTextOnCommit( true );
GradientStopMenu.BeginSection( NAME_None, LOCTEXT("TimeMenuSection", "Time") );
GradientStopMenu.AddWidget( EditableTextBox, FText::GetEmpty() );
GradientStopMenu.EndSection();
WidgetToFocus = EditableTextBox;
}
GradientStopMenu.AddMenuSeparator();
// Add a Remove option
GradientStopMenu.AddMenuEntry( LOCTEXT("RemoveGradientStop", "Remove Stop"), LOCTEXT("RemoveGradientStopTooltip", "Removes the selected gradient stop"), FSlateIcon(), RemoveStopAction );
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(AsShared(), WidgetPath, GradientStopMenu.MakeWidget(), Location, FPopupTransitionEffect::ContextMenu);
FSlateApplication::Get().SetKeyboardFocus( WidgetToFocus.ToSharedRef() );
}
ContextMenuPosition = Location;
}
TSharedPtr<SWidget> STrack::SummonContextMenu(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
bool SummonedContextMenu = false;
const bool bCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder( bCloseWindowAfterMenuSelection, EditorActions );
FVector2D CursorPos = MouseEvent.GetScreenSpacePosition();
float DataPos = LocalToDataX( MyGeometry.AbsoluteToLocal(CursorPos).X, MyGeometry );
// Context menu for a node
int NotifyIndex = GetHitNode(MyGeometry, MyGeometry.AbsoluteToLocal(CursorPos));
if(NotifyIndex != INDEX_NONE)
{
if(TrackNodes[NotifyIndex]->OnNodeRightClickContextMenu.IsBound())
{
TrackNodes[NotifyIndex]->OnNodeRightClickContextMenu.Execute(MenuBuilder);
SummonedContextMenu = true;
}
}
// Context menu for track itself
if(OnTrackRightClickContextMenu.IsBound())
{
SummonedContextMenu = true;
OnTrackRightClickContextMenu.Execute(MenuBuilder, DataPos, DraggableBarIndex);
}
// Build the menu if we actually added anything to it
TSharedPtr<SWidget> MenuContent;
if(SummonedContextMenu)
{
MenuContent = MenuBuilder.MakeWidget();
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(SharedThis(this), WidgetPath, MenuContent.ToSharedRef(), CursorPos, FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
}
return MenuContent;
}
void STableViewBase::OnRightMouseButtonUp(const FPointerEvent& MouseEvent)
{
const FVector2D& SummonLocation = MouseEvent.GetScreenSpacePosition();
const bool bShouldOpenContextMenu = !IsRightClickScrolling();
const bool bContextMenuOpeningBound = OnContextMenuOpening.IsBound();
if ( bShouldOpenContextMenu && bContextMenuOpeningBound )
{
// Get the context menu content. If NULL, don't open a menu.
TSharedPtr<SWidget> MenuContent = OnContextMenuOpening.Execute();
if( MenuContent.IsValid() )
{
bShowSoftwareCursor = false;
FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
FSlateApplication::Get().PushMenu(AsShared(), WidgetPath, MenuContent.ToSharedRef(), SummonLocation, FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
}
}
AmountScrolledWhileRightMouseDown = 0;
}
