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();
}
bool UMatineeTrackEventHelper::PreCreateKeyframe( UInterpTrack *Track, float KeyTime ) const
{
KeyframeAddDataName = NAME_None;
// Prompt user for name of new event.
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
check(Mode->InterpEd != NULL);
TSharedRef<STextEntryPopup> TextEntryPopup =
SNew(STextEntryPopup)
.Label(NSLOCTEXT("Matinee.Popups", "NewEventName", "New Event Name").ToString())
.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() )
{
EntryPopupWindow = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
TextEntryPopup->FocusDefaultWidget();
return false;
}
TSharedPtr<SWidget> SGraphPanel::SummonContextMenu(const FVector2D& WhereToSummon, const FVector2D& WhereToAddNode, UEdGraphNode* ForNode, UEdGraphPin* ForPin, const TArray<UEdGraphPin*>& DragFromPins, bool bShiftOperation)
{
if (OnGetContextMenuFor.IsBound())
{
FGraphContextMenuArguments SpawnInfo;
SpawnInfo.NodeAddPosition = WhereToAddNode;
SpawnInfo.GraphNode = ForNode;
SpawnInfo.GraphPin = ForPin;
SpawnInfo.DragFromPins = DragFromPins;
SpawnInfo.bShiftOperation = bShiftOperation;
FActionMenuContent FocusedContent = OnGetContextMenuFor.Execute(SpawnInfo);
TSharedRef<SWidget> MenuContent = FocusedContent.Content;
FSlateApplication::Get().PushMenu(
AsShared(),
MenuContent,
WhereToSummon,
FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu )
);
return FocusedContent.WidgetToFocus;
}
return TSharedPtr<SWidget>();
}
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 SDistributionCurveEditor::OnScaleValues(ECurveScaleScope::Type Scope)
{
FString DefaultText = FString::Printf(TEXT("%.2f"), 1.0f);
FText Label;
if(Scope == ECurveScaleScope::All)
{
Label = LOCTEXT("ScaleValueAll", "Scale Values (All): ");
}
else if(Scope == ECurveScaleScope::Current)
{
FCurveEdEntry& Entry = SharedData->EdSetup->Tabs[SharedData->EdSetup->ActiveTab].Curves[SharedData->RightClickCurveIndex];
Label = FText::Format(LOCTEXT("ScaleValue", "Scale Values ({0}): "), FText::FromString(Entry.CurveName));
}
else if( Scope == ECurveScaleScope::CurrentSub)
{
FCurveEdEntry& Entry = SharedData->EdSetup->Tabs[SharedData->EdSetup->ActiveTab].Curves[SharedData->RightClickCurveIndex];
Label = FText::Format(LOCTEXT("ScaleSubValue", "Scale Sub-Value ({0}:{1}): "), FText::FromString(Entry.CurveName), FText::AsNumber(SharedData->RightClickCurveSubIndex));
}
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(Label)
.DefaultText(FText::FromString( DefaultText ))
.OnTextCommitted(this, &SDistributionCurveEditor::ScaleValueCommitted, Scope)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false);
EntryPopupWindow = FSlateApplication::Get().PushMenu(
SharedThis(this),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
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();
}
void SDistributionCurveEditor::OpenLabelMenu()
{
const FVector2D MouseCursorLocation = FSlateApplication::Get().GetCursorPos();
FSlateApplication::Get().PushMenu(
SharedThis( this ),
BuildMenuWidgetLabel(),
MouseCursorLocation,
FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu)
);
}
void FActorDropTarget::OnDrop(FDragDropPayload& DraggedObjects, UWorld& World, const FDragValidationInfo& ValidationInfo, TSharedRef<SWidget> DroppedOnWidget)
{
AActor* DropActor = Actor.Get();
if (!DropActor)
{
return;
}
FActorArray DraggedActors = DraggedObjects.Actors.GetValue();
FMessageLog EditorErrors("EditorErrors");
EditorErrors.NewPage(LOCTEXT("ActorAttachmentsPageLabel", "Actor attachment"));
if (ValidationInfo.TooltipType == FActorDragDropGraphEdOp::ToolTip_CompatibleMultipleDetach || ValidationInfo.TooltipType == FActorDragDropGraphEdOp::ToolTip_CompatibleDetach)
{
const FScopedTransaction Transaction( LOCTEXT("UndoAction_DetachActors", "Detach actors") );
for (const auto& WeakActor : DraggedActors)
{
if (auto* DragActor = WeakActor.Get())
{
DetachActorFromParent(DragActor);
}
}
}
else if (ValidationInfo.TooltipType == FActorDragDropGraphEdOp::ToolTip_CompatibleMultipleAttach || ValidationInfo.TooltipType == FActorDragDropGraphEdOp::ToolTip_CompatibleAttach)
{
// Show socket chooser if we have sockets to select
//@TODO: Should create a menu for each component that contains sockets, or have some form of disambiguation within the menu (like a fully qualified path)
// Instead, we currently only display the sockets on the root component
USceneComponent* Component = DropActor->GetRootComponent();
if ((Component != NULL) && (Component->HasAnySockets()))
{
// Create the popup
FSlateApplication::Get().PushMenu(
DroppedOnWidget,
SNew(SSocketChooserPopup)
.SceneComponent( Component )
.OnSocketChosen_Static(&FActorDropTarget::PerformAttachment, Actor, MoveTemp(DraggedActors) ),
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect( FPopupTransitionEffect::TypeInPopup )
);
}
else
{
PerformAttachment(NAME_None, Actor, MoveTemp(DraggedActors));
}
}
// Report errors
EditorErrors.Notify(NSLOCTEXT("ActorAttachmentError", "AttachmentsFailed", "Attachments Failed!"));
}
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 SDistributionCurveEditor::OnCreateTab()
{
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(LOCTEXT("SetTabName", "Tab Name: "))
.OnTextCommitted(this, &SDistributionCurveEditor::TabNameCommitted)
.ClearKeyboardFocusOnCommit(false);
EntryPopupWindow = FSlateApplication::Get().PushMenu(
SharedThis(this),
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)
);
}
/**
* 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();
}
}
void FSequencer::RenameShot(UMovieSceneSection* ShotSection)
{
auto ActualShotSection = CastChecked<UMovieSceneShotSection>(ShotSection);
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(NSLOCTEXT("Sequencer", "RenameShotHeader", "Name"))
.DefaultText( ActualShotSection->GetTitle() )
.OnTextCommitted(this, &FSequencer::RenameShotCommitted, ShotSection)
.ClearKeyboardFocusOnCommit( false );
NameEntryPopupWindow = FSlateApplication::Get().PushMenu(
SequencerWidget.ToSharedRef(),
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*)GEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
check(Mode->InterpEd != NULL);
if ( (Mode != NULL) && (Mode->InterpEd != NULL) )
{
// Make array of group names
TArray<FString> GroupNames;
for ( int32 i = 0; i < Mode->InterpEd->GetInterpData()->InterpGroups.Num(); i++ )
{
// Skip folder groups
if( !Mode->InterpEd->GetInterpData()->InterpGroups[i]->bIsFolder)
{
GroupNames.Add( *(Mode->InterpEd->GetInterpData()->InterpGroups[i]->GroupName.ToString()) );
}
}
TSharedRef<STextComboPopup> TextEntryPopup =
SNew(STextComboPopup)
.Label(NSLOCTEXT("Matinee.Popups", "NewCut", "Cut to Group...").ToString())
.TextOptions(GroupNames)
.OnTextChosen_UObject(this, &UMatineeTrackDirectorHelper::OnAddKeyTextEntry, Mode->InterpEd, Track)
;
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
EntryPopupWindow = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
}
return false;
}
void SSessionConsoleShortcutWindow::HandleEditCommandActionExecute( TSharedPtr<FConsoleShortcutData> InShortcut, bool bInEditCommand, FText InPromptTitle )
{
FString DefaultString = bInEditCommand ? InShortcut->Command : InShortcut->Name;
EditedShortcut = InShortcut;
bEditCommand = bInEditCommand;
TSharedRef<STextEntryPopup> TextEntry = SNew(STextEntryPopup)
.Label(InPromptTitle)
.DefaultText(FText::FromString(*DefaultString))
.OnTextCommitted(this, &SSessionConsoleShortcutWindow::HandleShortcutTextEntryCommitted)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false);
NameEntryPopupWindow = FSlateApplication::Get().PushMenu(
SharedThis(this),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
bool UMatineeTrackToggleHelper::PreCreateKeyframe( UInterpTrack *Track, float KeyTime ) const
{
bool bResult = false;
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GEditorModeTools().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").ToString())
.TextOptions(PropStrings)
.OnTextChosen_UObject(this, &UMatineeTrackToggleHelper::OnAddKeyTextEntry, InterpEd, Track)
;
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
EntryPopupWindow = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
TextEntryPopup->FocusDefaultWidget();
return bResult;
}
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();
}
void SDistributionCurveEditor::OnSetValue()
{
FCurveEditorSelectedKey& SelKey = SharedData->SelectedKeys[0];
FCurveEdEntry& Entry = SharedData->EdSetup->Tabs[SharedData->EdSetup->ActiveTab].Curves[SelKey.CurveIndex];
FCurveEdInterface* EdInterface = UInterpCurveEdSetup::GetCurveEdInterfacePointer(Entry);
FString DefaultText = FString::Printf(TEXT("%.2f"), EdInterface->GetKeyOut(SelKey.SubIndex, SelKey.KeyIndex));
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(LOCTEXT("SetValue", "Value: "))
.DefaultText(FText::FromString(DefaultText))
.OnTextCommitted(this, &SDistributionCurveEditor::KeyValueCommitted)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false);
EntryPopupWindow = FSlateApplication::Get().PushMenu(
SharedThis(this),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
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;
TArray<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*)GEditorModeTools().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;
AssetPickerConfig.ThumbnailScale = 0.0f;
// 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();
EntryPopupWindow = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
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 SFlipbookKeyframeWidget::KeyframeOnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
{
TSharedRef<SWidget> MenuContents = GenerateContextMenu();
FSlateApplication::Get().PushMenu(AsShared(), MenuContents, MouseEvent.GetScreenSpacePosition(), FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
return FReply::Handled();
}
return FReply::Unhandled();
}
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();
}
void FLevelEditorContextMenu::SummonMenu( const TSharedRef< SLevelEditor >& LevelEditor, LevelEditorMenuContext ContextType )
{
struct Local
{
static void ExtendMenu( FMenuBuilder& MenuBuilder )
{
// one extra entry when summoning the menu this way
MenuBuilder.BeginSection("ActorPreview", LOCTEXT("PreviewHeading", "Preview") );
{
// Note: not using a command for play from here since it requires a mouse click
FUIAction PlayFromHereAction(
FExecuteAction::CreateStatic( &FPlayWorldCommandCallbacks::StartPlayFromHere ) );
const FText PlayFromHereLabel = GEditor->OnlyLoadEditorVisibleLevelsInPIE() ? LOCTEXT("PlayFromHereVisible", "Play From Here (visible levels)") : LOCTEXT("PlayFromHere", "Play From Here");
MenuBuilder.AddMenuEntry( PlayFromHereLabel, LOCTEXT("PlayFromHere_ToolTip", "Starts a game preview from the clicked location"),FSlateIcon(), PlayFromHereAction );
}
MenuBuilder.EndSection();
}
};
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
Extender->AddMenuExtension("LevelViewportAttach", EExtensionHook::After, TSharedPtr< FUICommandList >(), FMenuExtensionDelegate::CreateStatic(&Local::ExtendMenu));
// Create the context menu!
TSharedPtr<SWidget> MenuWidget = BuildMenuWidget( LevelEditor, ContextType, Extender );
if ( MenuWidget.IsValid() )
{
// @todo: Should actually use the location from a click event instead!
const FVector2D MouseCursorLocation = FSlateApplication::Get().GetCursorPos();
TWeakPtr< SWindow > ContextMenuWindow = FSlateApplication::Get().PushMenu(
LevelEditor->GetActiveViewport().ToSharedRef(), MenuWidget.ToSharedRef(), MouseCursorLocation, FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu ) );
}
}
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();
}
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;
}
/**
* Open or close the popup
*
* @param InIsOpen If true, open the popup. Otherwise close it.
*/
void SMenuAnchor::SetIsOpen( bool InIsOpen, const bool bFocusMenu )
{
// Prevent redundant opens/closes
if ( IsOpen() != InIsOpen )
{
if ( InIsOpen )
{
if ( OnGetMenuContent.IsBound() )
{
SetMenuContent(OnGetMenuContent.Execute());
}
if ( MenuContent.IsValid() )
{
// OPEN POPUP
if ( OnMenuOpenChanged.IsBound() )
{
OnMenuOpenChanged.Execute(true);
}
// Figure out where the menu anchor is on the screen, so we can set the initial position of our pop-up window
// This can be called at any time so we use the push menu override that explicitly allows us to specify our parent
// NOTE: Careful, GeneratePathToWidget can be reentrant in that it can call visibility delegates and such
FWidgetPath MyWidgetPath;
FSlateApplication::Get().GeneratePathToWidgetUnchecked(AsShared(), MyWidgetPath);
if (MyWidgetPath.IsValid())
{
const FGeometry& MyGeometry = MyWidgetPath.Widgets.Last().Geometry;
const float LayoutScaleMultiplier = MyGeometry.GetAccumulatedLayoutTransform().GetScale();
SlatePrepass(LayoutScaleMultiplier);
// Figure out how big the content widget is so we can set the window's initial size properly
TSharedRef< SWidget > MenuContentRef = MenuContent.ToSharedRef();
MenuContentRef->SlatePrepass(LayoutScaleMultiplier);
// Combo-boxes never size down smaller than the widget that spawned them, but all
// other pop-up menus are currently auto-sized
const FVector2D DesiredContentSize = MenuContentRef->GetDesiredSize(); // @todo slate: This is ignoring any window border size!
const EMenuPlacement PlacementMode = Placement.Get();
const FVector2D NewPosition = MyGeometry.AbsolutePosition;
FVector2D NewWindowSize = DesiredContentSize;
const FVector2D SummonLocationSize = MyGeometry.Size;
FPopupTransitionEffect TransitionEffect( FPopupTransitionEffect::None );
if ( PlacementMode == MenuPlacement_ComboBox || PlacementMode == MenuPlacement_ComboBoxRight )
{
TransitionEffect = FPopupTransitionEffect( FPopupTransitionEffect::ComboButton );
NewWindowSize = FVector2D( FMath::Max( MyGeometry.Size.X, DesiredContentSize.X ), DesiredContentSize.Y );
}
else if ( PlacementMode == MenuPlacement_BelowAnchor )
{
TransitionEffect = FPopupTransitionEffect( FPopupTransitionEffect::TopMenu );
}
else if ( PlacementMode == MenuPlacement_MenuRight )
{
TransitionEffect = FPopupTransitionEffect( FPopupTransitionEffect::SubMenu );
}
MethodInUse = Method.IsSet()
? Method.GetValue()
: QueryPopupMethod(MyWidgetPath);
if (MethodInUse == EPopupMethod::CreateNewWindow)
{
// Open the pop-up
const bool bIsCollapsedByParent = false; // don't auto-close child menus when the parent gets focus
TSharedPtr<IMenu> NewMenu = FSlateApplication::Get().PushMenu(AsShared(), MyWidgetPath, MenuContentRef, NewPosition, TransitionEffect, bFocusMenu, SummonLocationSize, MethodInUse, bIsCollapsedByParent);
PopupMenuPtr = NewMenu;
check(NewMenu.IsValid() && NewMenu->GetOwnedWindow().IsValid());
NewMenu->GetOnMenuDismissed().AddSP(this, &SMenuAnchor::OnMenuClosed);
PopupWindowPtr = NewMenu->GetOwnedWindow();
}
else
{
// We are re-using the current window instead of creating a new one.
// The popup will be presented via an overlay service.
ensure(MethodInUse == EPopupMethod::UseCurrentWindow);
TSharedRef<SWindow> PopupWindow = MyWidgetPath.GetWindow();
PopupWindowPtr = PopupWindow;
if (bFocusMenu)
{
FSlateApplication::Get().ReleaseMouseCapture();
}
TSharedRef<SMenuAnchor> SharedThis = StaticCastSharedRef<SMenuAnchor>(AsShared());
const bool bIsCollapsedByParent = false; // don't auto-close child menus when the parent gets focus
TSharedPtr<IMenu> NewMenu = FSlateApplication::Get().PushHostedMenu(
SharedThis, MyWidgetPath, SharedThis, MenuContentRef, WrappedContent, TransitionEffect, bIsCollapsedByParent);
PopupMenuPtr = NewMenu;
check(NewMenu.IsValid());
check(NewMenu->GetParentWindow().ToSharedRef() == PopupWindow);
check(WrappedContent.IsValid());
Children[1]
[
WrappedContent.ToSharedRef()
];
if (bFocusMenu)
{
FSlateApplication::Get().SetKeyboardFocus(MenuContentRef, EFocusCause::SetDirectly);
}
}
}
}
}
else
{
// CLOSE POPUP
if (PopupMenuPtr.IsValid())
{
PopupMenuPtr.Pin()->Dismiss();
}
else
{
PopupWindowPtr.Reset();
MethodInUse.Reset();
}
}
}
}
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));
}
}
/**
* Open or close the popup
*
* @param InIsOpen If true, open the popup. Otherwise close it.
*/
void SMenuAnchor::SetIsOpen( bool InIsOpen, const bool bFocusMenu )
{
// Prevent redundant opens/closes
if ( IsOpen() != InIsOpen )
{
if ( InIsOpen )
{
TSharedPtr< SWidget > MenuContentPtr = OnGetMenuContent.IsBound() ? OnGetMenuContent.Execute() : MenuContent;
if ( MenuContentPtr.IsValid() )
{
// OPEN POPUP
if ( OnMenuOpenChanged.IsBound() )
{
OnMenuOpenChanged.Execute(true);
}
// This can be called at any time so we use the push menu override that explicitly allows us to specify our parent
// Figure out where the menu anchor is on the screen, so we can set the initial position of our pop-up window
SlatePrepass();
// NOTE: Careful, GeneratePathToWidget can be reentrant in that it can call visibility delegates and such
FWidgetPath MyWidgetPath;
FSlateApplication::Get().GeneratePathToWidgetChecked(AsShared(), MyWidgetPath);
const FGeometry& MyGeometry = MyWidgetPath.Widgets.Last().Geometry;
// @todo Slate: This code does not properly propagate the layout scale of the widget we are creating the popup for.
// The popup instead has a scale of one, but a computed size as if the contents were scaled. This code should ideally
// wrap the contents with an SFxWidget that applies the necessary layout scale. This is a very rare case right now.
// Figure out how big the content widget is so we can set the window's initial size properly
TSharedRef< SWidget > MenuContentRef = MenuContentPtr.ToSharedRef();
MenuContentRef->SlatePrepass();
// Combo-boxes never size down smaller than the widget that spawned them, but all
// other pop-up menus are currently auto-sized
const FVector2D DesiredContentSize = MenuContentRef->GetDesiredSize(); // @todo: This is ignoring any window border size!
const EMenuPlacement PlacementMode = Placement.Get();
const FVector2D NewPosition = MyGeometry.AbsolutePosition;
FVector2D NewWindowSize = DesiredContentSize;
const FVector2D SummonLocationSize = MyGeometry.Size;
FPopupTransitionEffect TransitionEffect(FPopupTransitionEffect::None);
if ( PlacementMode == MenuPlacement_ComboBox || PlacementMode == MenuPlacement_ComboBoxRight )
{
TransitionEffect = FPopupTransitionEffect(FPopupTransitionEffect::ComboButton);
NewWindowSize = FVector2D(FMath::Max(MyGeometry.Size.X, DesiredContentSize.X), DesiredContentSize.Y);
}
else if ( PlacementMode == MenuPlacement_BelowAnchor )
{
TransitionEffect = FPopupTransitionEffect(FPopupTransitionEffect::TopMenu);
}
else if ( PlacementMode == MenuPlacement_MenuRight )
{
TransitionEffect = FPopupTransitionEffect(FPopupTransitionEffect::SubMenu);
}
if ( Method == CreateNewWindow )
{
// Open the pop-up
TSharedRef<SWindow> PopupWindow = FSlateApplication::Get().PushMenu(AsShared(), MenuContentRef, NewPosition, TransitionEffect, bFocusMenu, false, NewWindowSize, SummonLocationSize);
PopupWindow->SetRequestDestroyWindowOverride(FRequestDestroyWindowOverride::CreateSP(this, &SMenuAnchor::RequestClosePopupWindow));
PopupWindowPtr = PopupWindow;
}
else
{
// We are re-using the current window instead of creating a new one.
// The popup will be presented via an overlay service.
ensure(Method == UseCurrentWindow);
Children[1]
[
MenuContentRef
];
// We want to support dismissing the popup widget when the user clicks outside it.
FSlateApplication::Get().GetPopupSupport().RegisterClickNotification(MenuContentRef, FOnClickedOutside::CreateSP(this, &SMenuAnchor::OnClickedOutsidePopup));
}
if ( bFocusMenu )
{
FSlateApplication::Get().SetKeyboardFocus(MenuContentRef, EKeyboardFocusCause::SetDirectly);
}
}
}
else
{
// CLOSE POPUP
if (Method == CreateNewWindow)
{
// Close the Popup window.
TSharedPtr<SWindow> PopupWindow = PopupWindowPtr.Pin();
if ( PopupWindow.IsValid() )
{
// Request that the popup be closed.
PopupWindow->RequestDestroyWindow();
}
}
else
{
// Close the popup overlay
ensure(Method==UseCurrentWindow);
Children[1].DetachWidget();
}
if (OnMenuOpenChanged.IsBound())
{
OnMenuOpenChanged.Execute(false);
}
}
}
}
void FStaticMeshLightingInfoStatsPage::GetUserSetStaticLightmapResolution(TWeakPtr<IStatsViewer> InParentStatsViewer, bool bSwap) const
{
if(InParentStatsViewer.IsValid())
{
int32 DefaultRes = 0;
verify(GConfig->GetInt(TEXT("DevOptions.StaticLighting"), TEXT("DefaultStaticMeshLightingRes"), DefaultRes, GLightmassIni));
TSharedRef<STextEntryPopup> TextEntry =
SNew(STextEntryPopup)
.Label(LOCTEXT("StaticMeshLightingInfo_GetResolutionTitle", "Enter Lightmap Resolution"))
.HintText(LOCTEXT("StaticMeshLightingInfo_GetResolutionToolTip", "Will round to power of two"))
.DefaultText(FText::AsNumber(DefaultRes))
.OnTextCommitted( FOnTextCommitted::CreateSP( this, &FStaticMeshLightingInfoStatsPage::OnResolutionCommitted, InParentStatsViewer, bSwap ) )
.ClearKeyboardFocusOnCommit( false );
ResolutionEntryPopupWindow = FSlateApplication::Get().PushMenu(
InParentStatsViewer.Pin().ToSharedRef(),
TextEntry,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect( FPopupTransitionEffect::TypeInPopup )
);
TextEntry->FocusDefaultWidget();
}
}
