FReply SPaperEditorViewport::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
TotalMouseDelta = 0;
if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
{
// RIGHT BUTTON is for dragging and Context Menu.
FReply ReplyState = FReply::Handled();
ReplyState.CaptureMouse( SharedThis(this) );
ReplyState.UseHighPrecisionMouseMovement( SharedThis(this) );
SoftwareCursorPosition = PanelCoordToGraphCoord( MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ) );
// clear any interpolation when you manually pan
//DeferredMovementTargetObject = nullptr;
return ReplyState;
}
else if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
// START MARQUEE SELECTION.
const FVector2D GraphMousePos = PanelCoordToGraphCoord( MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ) );
Marquee.Start( GraphMousePos, FMarqueeOperation::OperationTypeFromMouseEvent(MouseEvent) );
// Trigger a selection update now so that single-clicks without a drag still select something
OnSelectionChanged.ExecuteIfBound(Marquee, true);
PaperViewportClient->Invalidate();
return FReply::Handled().CaptureMouse( SharedThis(this) );
}
else
{
return FReply::Unhandled();
}
}
FReply FSceneViewport::OnMouseButtonDoubleClick( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent )
{
// Start a new reply state
CurrentReplyState = FReply::Handled();
// Note: When double-clicking, the following message sequence is sent:
// WM_*BUTTONDOWN
// WM_*BUTTONUP
// WM_*BUTTONDBLCLK (Needs to set the KeyStates[*] to true)
// WM_*BUTTONUP
KeyStateMap.Add( InMouseEvent.GetEffectingButton(), true );
UpdateCachedMousePos( InGeometry, InMouseEvent );
UpdateCachedGeometry(InGeometry);
if( ViewportClient && GetSizeXY() != FIntPoint::ZeroValue )
{
// Switch to the viewport clients world before processing input
FScopedConditionalWorldSwitcher WorldSwitcher( ViewportClient );
if( !ViewportClient->InputKey( this, 0, InMouseEvent.GetEffectingButton(), IE_DoubleClick ) )
{
CurrentReplyState = FReply::Unhandled();
}
}
return CurrentReplyState;
}
FReply SColorGradientEditor::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( IsEditingEnabled.Get() == true )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
// Select the stop under the mouse if any and capture the mouse to get detect dragging
SelectedStop = GetGradientStopAtPoint( MouseEvent.GetScreenSpacePosition(), MyGeometry );
return FReply::Handled().CaptureMouse( SharedThis(this) );
}
else if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
FGradientStopMark PossibleSelectedStop = GetGradientStopAtPoint( MouseEvent.GetScreenSpacePosition(), MyGeometry );
if( PossibleSelectedStop.IsValid( *CurveOwner ) )
{
// Only change selection on right click if something was selected
SelectedStop = PossibleSelectedStop;
return FReply::Handled().CaptureMouse( SharedThis( this ) );
}
}
}
return FReply::Unhandled();
}
FReply SProfilerThreadView::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
FReply Reply = FReply::Unhandled();
if( IsReady() )
{
const FVector2D MousePositionOnButtonUp = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
const bool bIsValidForMouseClick = MousePositionOnButtonUp.Equals( MousePositionOnButtonDown, MOUSE_SNAP_DISTANCE );
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
if( bIsLeftMousePressed )
{
// Release the mouse, we are no longer dragging.
Reply = FReply::Handled().ReleaseMouseCapture();
}
bIsLeftMousePressed = false;
}
else if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
if( bIsRightMousePressed )
{
if( bIsValidForMouseClick )
{
ShowContextMenu( MouseEvent.GetScreenSpacePosition() );
Reply = FReply::Handled();
}
}
bIsRightMousePressed = false;
}
}
return Reply;
}
FReply SScrubWidget::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
bool bHandleLeftMouseButton = MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton;
bool bHandleRightMouseButton = MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && bAllowZoom;
bMouseMovedDuringPanning = false;
if ( bHandleLeftMouseButton )
{
if(DraggableBarIndex != INDEX_NONE)
{
DraggingBar = true;
}
else
{
DistanceDragged = 0;
}
// This has prevent throttling on so that viewports continue to run whilst dragging the slider
return FReply::Handled().CaptureMouse( SharedThis(this) ).PreventThrottling();
}
else if ( bHandleRightMouseButton )
{
bPanning = true;
// Always capture mouse if we left or right click on the widget
return FReply::Handled().CaptureMouse(SharedThis(this));
}
return FReply::Unhandled();
}
FReply SSection::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
DistanceDragged = 0;
DragOperation.Reset();
bDragging = false;
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton || MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
// Check for clicking on a key and mark it as the pressed key for drag detection (if necessary) later
PressedKey = GetKeyUnderMouse( MouseEvent.GetScreenSpacePosition(), MyGeometry );
if( !PressedKey.IsValid() && MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
CheckForEdgeInteraction( MouseEvent, MyGeometry );
}
return FReply::Handled().CaptureMouse( AsShared() );
}
else if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
return FReply::Handled().CaptureMouse(AsShared());
}
return FReply::Handled();
}
FReply SAnimationOutlinerTreeNode::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton && DisplayNode->IsSelectable() )
{
bool bSelected = DisplayNode->IsSelected();
if( MouseEvent.IsControlDown() )
{
const bool bDeselectOtherNodes = false;
// Select the node if we were clicked on
DisplayNode->SetSelectionState( !bSelected, bDeselectOtherNodes );
}
else
{
const bool bDeselectOtherNodes = true;
// Select the node if we were clicked on
DisplayNode->SetSelectionState( true, bDeselectOtherNodes );
}
OnSelectionChanged.ExecuteIfBound( DisplayNode );
return FReply::Handled();
}
else if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
return FReply::Handled().CaptureMouse(SharedThis(this));
}
return FReply::Unhandled();
}
FReply SGestureTreeItem::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton && FMultiBoxSettings::IsInToolbarEditMode())
{
return FReply::Handled().DetectDrag(SharedThis(this), MouseEvent.GetEffectingButton());
}
return FReply::Unhandled();
}
FReply FTextEditHelper::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& InMouseEvent, const TSharedRef< ITextEditorWidget >& TextEditor )
{
FReply Reply = FReply::Unhandled();
// The mouse must have been captured by either left or right button down before we'll process mouse ups
if( TextEditor->GetWidget()->HasMouseCapture() )
{
if( InMouseEvent.GetEffectingButton() == EKeys::LeftMouseButton &&
TextEditor->IsDragSelecting() )
{
// No longer drag-selecting
TextEditor->EndDragSelection();
// If we received keyboard focus on this click, then we'll want to select all of the text
// when the user releases the mouse button, unless the user actually dragged the mouse
// while holding the button down, in which case they've already selected some text and
// we'll leave things alone!
if( TextEditor->WasFocusedByLastMouseDown() )
{
if( !TextEditor->HasDragSelectedSinceFocused() )
{
if( TextEditor->SelectAllTextWhenFocused() )
{
// Move the cursor to the end of the string
TextEditor->JumpTo(ETextLocation::EndOfDocument, ECursorAction::MoveCursor);
// User wasn't dragging the mouse, so go ahead and select all of the text now
// that we've become focused
TextEditor->SelectAllText();
// @todo Slate: In this state, the caret should actually stay hidden (until the user interacts again), and we should not move the caret
}
}
TextEditor->SetWasFocusedByLastMouseDown( false );
}
// Release mouse capture
Reply = FReply::Handled();
Reply.ReleaseMouseCapture();
}
else if( InMouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
if ( MyGeometry.IsUnderLocation( InMouseEvent.GetScreenSpacePosition() ) )
{
// Right clicked, so summon a context menu if the cursor is within the widget
TextEditor->SummonContextMenu( InMouseEvent.GetScreenSpacePosition() );
}
// Release mouse capture
Reply = FReply::Handled();
Reply.ReleaseMouseCapture();
}
}
return Reply;
}
FReply SMultiBlockDragHandle::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton && Block->GetAction().IsValid() )
{
return FReply::Handled().DetectDrag( SharedThis(this), MouseEvent.GetEffectingButton() );
}
return FReply::Unhandled();
}
FReply SColorGradientEditor::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
const float DragThresholdDist = 5.0f;
if( IsEditingEnabled.Get() == true )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
if( bDraggingStop == true )
{
// We stopped dragging
GEditor->EndTransaction();
}
else if( DistanceDragged < DragThresholdDist && !SelectedStop.IsValid( *CurveOwner ) )
{
FGeometry ColorMarkAreaGeometry = GetColorMarkAreaGeometry( MyGeometry );
FGeometry AlphaMarkAreaGeometry = GetAlphaMarkAreaGeometry( MyGeometry );
if( ColorMarkAreaGeometry.IsUnderLocation( MouseEvent.GetScreenSpacePosition() ) )
{
// Add a new color mark
bool bColorStop = true;
SelectedStop = AddStop( MouseEvent.GetScreenSpacePosition(), MyGeometry, bColorStop );
return FReply::Handled().CaptureMouse( SharedThis(this) );
}
else if( AlphaMarkAreaGeometry.IsUnderLocation( MouseEvent.GetScreenSpacePosition() ) )
{
// Add a new alpha mark
bool bColorStop = false;
SelectedStop = AddStop( MouseEvent.GetScreenSpacePosition(), MyGeometry, bColorStop );
return FReply::Handled().CaptureMouse( SharedThis(this) );
}
}
DistanceDragged = 0;
bDraggingStop = false;
return FReply::Handled().ReleaseMouseCapture();
}
else if( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
// Didnt move the mouse too far, open a context menu
if( DistanceDragged < DragThresholdDist && SelectedStop.IsValid( *CurveOwner ) )
{
OpenGradientStopContextMenu( MouseEvent.GetScreenSpacePosition() );
}
DistanceDragged = 0;
return FReply::Handled().ReleaseMouseCapture();
}
}
return FReply::Unhandled();
}
FReply FSceneViewport::OnMouseButtonUp( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent )
{
// Start a new reply state
CurrentReplyState = FReply::Handled();
KeyStateMap.Add( InMouseEvent.GetEffectingButton(), false );
UpdateModifierKeys( InMouseEvent );
UpdateCachedMousePos( InGeometry, InMouseEvent );
UpdateCachedGeometry(InGeometry);
// Switch to the viewport clients world before processing input
FScopedConditionalWorldSwitcher WorldSwitcher( ViewportClient );
bool bCursorVisible = true;
bool bReleaseMouse = true;
if( ViewportClient && GetSizeXY() != FIntPoint::ZeroValue )
{
if (!ViewportClient->InputKey(this, InMouseEvent.GetUserIndex(), InMouseEvent.GetEffectingButton(), IE_Released))
{
CurrentReplyState = FReply::Unhandled();
}
bCursorVisible = ViewportClient->GetCursor(this, GetMouseX(), GetMouseY()) != EMouseCursor::None;
bReleaseMouse =
bCursorVisible ||
ViewportClient->CaptureMouseOnClick() == EMouseCaptureMode::CaptureDuringMouseDown ||
( ViewportClient->CaptureMouseOnClick() == EMouseCaptureMode::CaptureDuringRightMouseDown && InMouseEvent.GetEffectingButton() == EKeys::RightMouseButton );
}
if (!((FApp::IsGame() && !GIsEditor) || bIsPlayInEditorViewport) || bReleaseMouse)
{
// On mouse up outside of the game (editor viewport) or if the cursor is visible in game, we should make sure the mouse is no longer captured
// as long as the left or right mouse buttons are not still down
if( !InMouseEvent.IsMouseButtonDown( EKeys::RightMouseButton ) && !InMouseEvent.IsMouseButtonDown( EKeys::LeftMouseButton ))
{
if( bCursorHiddenDueToCapture )
{
bCursorHiddenDueToCapture = false;
CurrentReplyState.SetMousePos( MousePosBeforeHiddenDueToCapture );
MousePosBeforeHiddenDueToCapture = FIntPoint( -1, -1 );
}
CurrentReplyState.ReleaseMouseCapture();
if (bCursorVisible)
{
CurrentReplyState.ReleaseMouseLock();
}
}
}
return CurrentReplyState;
}
FReply STransformHandle::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
Action = ComputeActionAtLocation(MyGeometry, MouseEvent);
FWidgetReference SelectedWidget = Designer->GetSelectedWidget();
UWidget* Preview = SelectedWidget.GetPreview();
UWidget* Template = SelectedWidget.GetTemplate();
if ( UCanvasPanelSlot* Slot = Cast<UCanvasPanelSlot>(Preview->Slot) )
{
StartingOffsets = Slot->GetOffsets();
}
MouseDownPosition = MouseEvent.GetScreenSpacePosition();
ScopedTransaction = new FScopedTransaction(LOCTEXT("ResizeWidget", "Resize Widget"));
Template->Modify();
return FReply::Handled().CaptureMouse(SharedThis(this));
}
return FReply::Unhandled();
}
FReply SGraphPinColor::OnColorBoxClicked(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
SelectedColor = GetColor();
TArray<FLinearColor*> LinearColorArray;
LinearColorArray.Add(&SelectedColor);
FColorPickerArgs PickerArgs;
PickerArgs.bIsModal = true;
PickerArgs.ParentWidget = AsShared();
PickerArgs.DisplayGamma = TAttribute<float>::Create(TAttribute<float>::FGetter::CreateUObject(GEngine, &UEngine::GetDisplayGamma));
PickerArgs.LinearColorArray = &LinearColorArray;
PickerArgs.OnColorCommitted = FOnLinearColorValueChanged::CreateSP(this, &SGraphPinColor::OnColorCommitted);
PickerArgs.bUseAlpha = true;
OpenColorPicker(PickerArgs);
return FReply::Handled();
}
else
{
return FReply::Unhandled();
}
}
FReply STableViewBase::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if ( MouseEvent.GetEffectingButton() == EKeys::RightMouseButton )
{
OnRightMouseButtonUp( MouseEvent );
FReply Reply = FReply::Handled().ReleaseMouseCapture();
bShowSoftwareCursor = false;
// If we have mouse capture, snap the mouse back to the closest location that is within the list's bounds
if ( HasMouseCapture() )
{
FSlateRect ListScreenSpaceRect = MyGeometry.GetClippingRect();
FVector2D CursorPosition = MyGeometry.LocalToAbsolute( SoftwareCursorPosition );
FIntPoint BestPositionInList(
FMath::RoundToInt( FMath::Clamp( CursorPosition.X, ListScreenSpaceRect.Left, ListScreenSpaceRect.Right ) ),
FMath::RoundToInt( FMath::Clamp( CursorPosition.Y, ListScreenSpaceRect.Top, ListScreenSpaceRect.Bottom ) )
);
Reply.SetMousePos(BestPositionInList);
}
return Reply;
}
return FReply::Unhandled();
}
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();
}
FReply SCaptureRegionWidget::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if (IsEnabled() && MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
FVector2D ViewportPosition = MouseEvent.GetScreenSpacePosition() - MyGeometry.AbsolutePosition;
FIntRect& CurrentCaptureRegion = GetHighResScreenshotConfig().UnscaledCaptureRegion;
switch (CurrentState)
{
case State_Dragging:
{
BuildNewCaptureRegion(ViewportPosition, DragStartPosition);
CurrentState = State_Inactive;
bIgnoreExistingCaptureRegion = false;
break;
}
case State_XAxisResize:
{
ViewportPosition.Y = CurrentCaptureRegion.Max.Y;
BuildNewCaptureRegion(ViewportPosition, DragStartPosition);
CurrentState = State_Inactive;
break;
}
case State_YAxisResize:
{
ViewportPosition.X = CurrentCaptureRegion.Max.X;
BuildNewCaptureRegion(ViewportPosition, DragStartPosition);
CurrentState = State_Inactive;
break;
}
case State_Moving:
{
CurrentState = State_Inactive;
//OnCaptureRegionChanged.ExecuteIfBound(CurrentCaptureRegion);
SendUpdatedCaptureRegion();
break;
}
case State_Inactive:
{
break;
}
default:
{
check(false);
break;
}
}
return FReply::Handled();
}
else
{
return FReply::Unhandled();
}
}
FReply FScrollyZoomy::OnMouseButtonUp( const TSharedRef<SWidget> MyWidget, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
{
AmountScrolledWhileRightMouseDown = 0;
FReply Reply = FReply::Handled().ReleaseMouseCapture();
bShowSoftwareCursor = false;
// If we have mouse capture, snap the mouse back to the closest location that is within the panel's bounds
if (MyWidget->HasMouseCapture())
{
FSlateRect PanelScreenSpaceRect = MyGeometry.GetClippingRect();
FVector2D CursorPosition = MyGeometry.LocalToAbsolute( SoftwareCursorPosition );
FIntPoint BestPositionInPanel(
FMath::RoundToInt( FMath::Clamp( CursorPosition.X, PanelScreenSpaceRect.Left, PanelScreenSpaceRect.Right ) ),
FMath::RoundToInt( FMath::Clamp( CursorPosition.Y, PanelScreenSpaceRect.Top, PanelScreenSpaceRect.Bottom ) )
);
Reply.SetMousePos( BestPositionInPanel );
}
if (!bUseIntertialScrolling)
{
HorizontalIntertia.ClearScrollVelocity();
VerticalIntertia.ClearScrollVelocity();
}
return Reply;
}
return FReply::Unhandled();
}
FReply SButton::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
FReply Reply = FReply::Unhandled();
if (IsEnabled() && (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton || MouseEvent.IsTouchEvent()))
{
Press();
if( ClickMethod == EButtonClickMethod::MouseDown )
{
//get the reply from the execute function
Reply = OnClicked.IsBound() ? OnClicked.Execute() : FReply::Handled();
//You should ALWAYS handle the OnClicked event.
ensure(Reply.IsEventHandled() == true);
}
else if ( IsPreciseTapOrClick(MouseEvent) )
{
// do not capture the pointer for precise taps or clicks
//
}
else
{
//we need to capture the mouse for MouseUp events
Reply = FReply::Handled().CaptureMouse( AsShared() );
}
}
Invalidate(EInvalidateWidget::Layout);
//return the constructed reply
return Reply;
}
/**
* 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 SARActionItemWidget::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (CurrentAbility.IsValid())
{
return FReply::Handled().DetectDrag(SharedThis(this), MouseEvent.GetEffectingButton()).CaptureMouse(SharedThis(this));
}
return FReply::Unhandled();
}
void SSection::CheckForEdgeInteraction( const FPointerEvent& MouseEvent, const FGeometry& SectionGeometry )
{
bLeftEdgeHovered = false;
bRightEdgeHovered = false;
bLeftEdgePressed = false;
bRightEdgePressed = false;
if (!SectionInterface->SectionIsResizable())
{
return;
}
// Make areas to the left and right of the geometry. We will use these areas to determine if someone dragged the left or right edge of a section
FGeometry SectionRectLeft = SectionGeometry.MakeChild(
FVector2D::ZeroVector,
FVector2D( SequencerSectionConstants::SectionGripSize, SectionGeometry.Size.Y )
);
FGeometry SectionRectRight = SectionGeometry.MakeChild(
FVector2D( SectionGeometry.Size.X - SequencerSectionConstants::SectionGripSize, 0 ),
SectionGeometry.Size
);
if( SectionRectLeft.IsUnderLocation( MouseEvent.GetScreenSpacePosition() ) )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
bLeftEdgePressed = true;
}
else
{
bLeftEdgeHovered = true;
}
}
else if( SectionRectRight.IsUnderLocation( MouseEvent.GetScreenSpacePosition() ) )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
bRightEdgePressed = true;
}
else
{
bRightEdgeHovered = true;
}
}
}
virtual FReply OnSectionDoubleClicked( const FGeometry& SectionGeometry, const FPointerEvent& MouseEvent ) override
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
Sequencer.Pin()->FocusSubMovieScene( MovieSceneInstance.Pin().ToSharedRef() );
}
return FReply::Handled();
}
FReply SVisualLoggerTimelinesContainer::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() != EKeys::LeftMouseButton)
{
return TimeSliderController->OnMouseMove(*this, MyGeometry, MouseEvent);
}
return FReply::Unhandled();
}
FReply SButton::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
FReply Reply = FReply::Unhandled();
const bool bMustBePressed = ClickMethod == EButtonClickMethod::DownAndUp;
const bool bMeetsPressedRequirements = (!bMustBePressed || (bIsPressed && bMustBePressed));
if (bMeetsPressedRequirements && IsEnabled() && ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton || MouseEvent.IsTouchEvent() ) )
{
Release();
if( ClickMethod == EButtonClickMethod::MouseDown )
{
// NOTE: If we're configured to click on mouse-down/precise-tap, then we never capture the mouse thus
// may never receive an OnMouseButtonUp() call. We make sure that our bIsPressed
// state is reset by overriding OnMouseLeave().
}
else
{
bool bEventOverButton = IsHovered();
if (!bEventOverButton && MouseEvent.IsTouchEvent())
{
bEventOverButton = MyGeometry.IsUnderLocation(MouseEvent.GetScreenSpacePosition());
}
if (bEventOverButton)
{
// If we asked for a precise tap, all we need is for the user to have not moved their pointer very far.
const bool bTriggerForTouchEvent = IsPreciseTapOrClick(MouseEvent);
// If we were asked to allow the button to be clicked on mouse up, regardless of whether the user
// pressed the button down first, then we'll allow the click to proceed without an active capture
const bool bTriggerForMouseEvent = ( ClickMethod == EButtonClickMethod::MouseUp || HasMouseCapture() );
if( (bTriggerForTouchEvent || bTriggerForMouseEvent) && OnClicked.IsBound() == true )
{
Reply = OnClicked.Execute();
}
}
}
//If the user of the button didn't handle this click, then the button's
//default behavior handles it.
if ( Reply.IsEventHandled() == false )
{
Reply = FReply::Handled();
}
//If the user hasn't requested a new mouse captor and the button still has mouse capture,
//then the default behavior of the button is to release mouse capture.
if (Reply.GetMouseCaptor().IsValid() == false && HasMouseCapture())
{
Reply.ReleaseMouseCapture();
}
}
Invalidate(EInvalidateWidget::Layout);
return Reply;
}
FReply FSequencerTimeSliderController::OnMouseButtonUp( TSharedRef<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)
{
// 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( bDraggingScrubber )
{
TimeSliderArgs.OnEndScrubberMovement.ExecuteIfBound();
}
else
{
FScrubRangeToScreen RangeToScreen( TimeSliderArgs.ViewRange.Get(), MyGeometry.Size );
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetLastScreenSpacePosition());
float NewValue = RangeToScreen.LocalXToInput(CursorPos.X);
const USequencerSnapSettings* SnapSettings = GetDefault<USequencerSnapSettings>();
if ( SnapSettings->GetIsSnapEnabled() && SnapSettings->GetSnapPlayTimeToInterval() )
{
NewValue = SnapSettings->SnapToInterval( NewValue );
}
CommitScrubPosition( NewValue, /*bIsScrubbing=*/false );
}
bDraggingScrubber = false;
return FReply::Handled().ReleaseMouseCapture();
}
return FReply::Unhandled();
}
FReply SScrubWidget::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
bool bHandleLeftMouseButton = MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton && this->HasMouseCapture();
bool bHandleRightMouseButton = MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && this->HasMouseCapture() && bAllowZoom;
if ( bHandleRightMouseButton )
{
bPanning = false;
FTrackScaleInfo TimeScaleInfo(ViewInputMin.Get(), ViewInputMax.Get(), 0.f, 0.f, MyGeometry.Size);
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetLastScreenSpacePosition());
float NewValue = TimeScaleInfo.LocalXToInput(CursorPos.X);
if( !bMouseMovedDuringPanning )
{
CreateContextMenu(NewValue, MouseEvent);
}
return FReply::Handled().ReleaseMouseCapture();
}
else if ( bHandleLeftMouseButton )
{
if(DraggingBar)
{
DraggingBar = false;
}
else if( bDragging )
{
OnEndSliderMovement.ExecuteIfBound( ValueAttribute.Get() );
}
else
{
FTrackScaleInfo TimeScaleInfo(ViewInputMin.Get(), ViewInputMax.Get(), 0.f, 0.f, MyGeometry.Size);
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetLastScreenSpacePosition());
float NewValue = TimeScaleInfo.LocalXToInput(CursorPos.X);
CommitValue( NewValue, true, false );
}
bDragging = false;
return FReply::Handled().ReleaseMouseCapture();
}
return FReply::Unhandled();
}
FReply STimelineLabelAnchor::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && TimelineOwner.IsValid() && TimelineOwner.Pin()->IsSelected())
{
SetIsOpen(!IsOpen());
return FReply::Handled();
}
return FReply::Unhandled();
}
FReply SFlipbookKeyframeWidget::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
return FReply::Handled().DetectDrag(SharedThis(this), EKeys::LeftMouseButton);
}
return FReply::Unhandled();
}
FReply SSplitter2x2::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton && bIsResizing == true )
{
bIsResizing = false;
return FReply::Handled().ReleaseMouseCapture();
}
return FReply::Unhandled();
}