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();
}
}
void SGraphNodeDocumentation::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
if( !bUserIsDragging )
{
ChildWidgetVisibility = EVisibility::HitTestInvisible;
FVector2D LocalMouseCoordinates = AllottedGeometry.AbsoluteToLocal( FSlateApplication::Get().GetCursorPos() );
EResizableWindowZone CurrMouseZone = FindMouseZone( LocalMouseCoordinates );
if( CurrMouseZone == CRWZ_InWindow )
{
ChildWidgetVisibility = EVisibility::Visible;
}
}
// Check Cached Links to determine if we need to update the documention link/excerpt
if( CachedDocumentationLink != GraphNode->GetDocumentationLink() ||
CachedDocumentationExcerpt != GraphNode->GetDocumentationExcerptName())
{
GraphNode->NodeWidth = 0.f;
GraphNode->NodeHeight = 0.f;
UpdateGraphNode();
}
SGraphNodeResizable::Tick( AllottedGeometry, InCurrentTime, InDeltaTime );
}
FReply SGraphPanel::OnDragOver( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return FReply::Unhandled();
}
// Handle Read only graphs
if( !IsEditable.Get() )
{
TSharedPtr<FGraphEditorDragDropAction> GraphDragDropOp = DragDropEvent.GetOperationAs<FGraphEditorDragDropAction>();
if( GraphDragDropOp.IsValid() )
{
GraphDragDropOp->SetDropTargetValid( false );
}
else
{
TSharedPtr<FDecoratedDragDropOp> AssetOp = DragDropEvent.GetOperationAs<FDecoratedDragDropOp>();
if( AssetOp.IsValid() )
{
FText Tooltip = AssetOp->GetHoverText();
if( Tooltip.IsEmpty() )
{
Tooltip = NSLOCTEXT( "GraphPanel", "DragDropOperation", "Graph is Read-Only" );
}
AssetOp->SetToolTip( Tooltip, FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error")));
}
}
return FReply::Handled();
}
if( Operation->IsOfType<FGraphEditorDragDropAction>() )
{
PreviewConnectorEndpoint = MyGeometry.AbsoluteToLocal( DragDropEvent.GetScreenSpacePosition() );
return FReply::Handled();
}
else if (Operation->IsOfType<FExternalDragOperation>())
{
return AssetUtil::CanHandleAssetDrag(DragDropEvent);
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
if(GraphObj != NULL && GraphObj->GetSchema())
{
TSharedPtr<FAssetDragDropOp> AssetOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
bool bOkIcon = false;
FString TooltipText;
GraphObj->GetSchema()->GetAssetsGraphHoverMessage(AssetOp->AssetData, GraphObj, TooltipText, bOkIcon);
const FSlateBrush* TooltipIcon = bOkIcon ? FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK")) : FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));;
AssetOp->SetToolTip(FText::FromString(TooltipText), TooltipIcon);
}
return FReply::Handled();
}
else
{
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;
}
FGradientStopMark SColorGradientEditor::AddStop( const FVector2D& Position, const FGeometry& MyGeometry, bool bColorStop )
{
FScopedTransaction AddStopTrans( LOCTEXT("AddGradientStop", "Add Gradient Stop") );
CurveOwner->ModifyOwner();
FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), 0.0f, 1.0f, MyGeometry.Size);
FVector2D LocalPos = MyGeometry.AbsoluteToLocal( Position );
float NewStopTime = ScaleInfo.LocalXToInput( LocalPos.X );
TArray<FRichCurveEditInfo> Curves = CurveOwner->GetCurves();
FGradientStopMark NewStop;
NewStop.Time = NewStopTime;
if( bColorStop )
{
FRichCurve* RedCurve = Curves[0].CurveToEdit;
FRichCurve* GreenCurve = Curves[1].CurveToEdit;
FRichCurve* BlueCurve = Curves[2].CurveToEdit;
NewStop.RedKeyHandle = RedCurve->AddKey( NewStopTime, LastModifiedColor.R );
NewStop.GreenKeyHandle = GreenCurve->AddKey( NewStopTime, LastModifiedColor.G );
NewStop.BlueKeyHandle = BlueCurve->AddKey( NewStopTime, LastModifiedColor.B );
}
else
{
FRichCurve* AlphaCurve = Curves[3].CurveToEdit;
NewStop.AlphaKeyHandle = AlphaCurve->AddKey( NewStopTime, LastModifiedColor.A );
}
return NewStop;
}
FReply FSequencerEditTool_Movement::OnMouseMove(SWidget& OwnerWidget, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (DelayedDrag.IsSet())
{
const FVirtualTrackArea VirtualTrackArea = SequencerWidget.Pin()->GetVirtualTrackArea();
FReply Reply = FReply::Handled();
if (DelayedDrag->IsDragging())
{
// If we're already dragging, just update the drag op if it exists
if (DragOperation.IsValid())
{
DragOperation->OnDrag(MouseEvent, MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition()), VirtualTrackArea);
}
}
// Otherwise we can attempt a new drag
else if (DelayedDrag->AttemptDragStart(MouseEvent))
{
DragOperation = CreateDrag();
if (DragOperation.IsValid())
{
DragOperation->OnBeginDrag(MouseEvent, DelayedDrag->GetInitialPosition(), VirtualTrackArea);
// Steal the capture, as we're now the authoritative widget in charge of a mouse-drag operation
Reply.CaptureMouse(OwnerWidget.AsShared());
}
}
return Reply;
}
return FReply::Unhandled();
}
/**
* The system calls this method to notify the widget that a mouse moved within it. This event is bubbled.
*
* @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 SGraphBar::OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
const float HoverX = ( MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ).X / MyGeometry.Size.X ) / Zoom - Offset / Zoom;
int32 HoveredEventIndex = INDEX_NONE;
for( int32 EventIndex = 0; EventIndex < Events.Num(); EventIndex++ )
{
TSharedPtr< FVisualizerEvent > Event = Events[ EventIndex ];
if( HoverX >= Event->Start && HoverX < ( Event->Start + Event->Duration ) )
{
HoveredEventIndex = EventIndex;
break;
}
}
if( HoveredEventIndex != LastHoveredEvent )
{
if( HoveredEventIndex != INDEX_NONE )
{
this->SetToolTipText( FText::FromString(Events[HoveredEventIndex]->EventName) );
}
else
{
this->SetToolTipText( FText::GetEmpty() );
}
LastHoveredEvent = HoveredEventIndex;
}
return SLeafWidget::OnMouseMove( MyGeometry, MouseEvent );
}
FReply SPaperEditorViewport::OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
// We want to zoom into this point; i.e. keep it the same fraction offset into the panel
const FVector2D WidgetSpaceCursorPos = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
FVector2D PointToMaintainGraphSpace = PanelCoordToGraphCoord( WidgetSpaceCursorPos );
const int32 ZoomLevelDelta = FMath::FloorToInt(MouseEvent.GetWheelDelta());
const bool bAllowFullZoomRange = true;
const float OldZoomLevel = ZoomLevel;
if (bAllowFullZoomRange)
{
ZoomLevel = FMath::Clamp( ZoomLevel + ZoomLevelDelta, 0, NumZoomLevels-1 );
}
else
{
// Without control, we do not allow zooming out past 1:1.
ZoomLevel = FMath::Clamp( ZoomLevel + ZoomLevelDelta, 0, DefaultZoomLevel );
}
ZoomLevelFade.Play(this->AsShared());
// Re-center the screen so that it feels like zooming around the cursor.
ViewOffset = PointToMaintainGraphSpace - WidgetSpaceCursorPos / GetZoomAmount();
return FReply::Handled();
}
FReply SColorGradientEditor::OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( HasMouseCapture() && IsEditingEnabled.Get() == true )
{
DistanceDragged += FMath::Abs( MouseEvent.GetCursorDelta().X );
if( MouseEvent.IsMouseButtonDown( EKeys::LeftMouseButton ) && SelectedStop.IsValid( *CurveOwner ) )
{
const float DragThresholdDist = 5.0f;
if( !bDraggingStop )
{
if( DistanceDragged >= DragThresholdDist )
{
// Start a transaction, we just started dragging a stop
bDraggingStop = true;
GEditor->BeginTransaction( LOCTEXT("MoveGradientStop", "Move Gradient Stop") );
CurveOwner->ModifyOwner();
}
return FReply::Handled();
}
else
{
// Already dragging a stop, move it
FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), 0.0f, 1.0f, MyGeometry.Size);
float MouseTime = ScaleInfo.LocalXToInput( MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ).X );
MoveStop( SelectedStop, MouseTime );
return FReply::Handled();
}
}
}
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 SRealtimeProfilerLineGraph::OnMouseMove( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent )
{
MousePosition = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
if(bIsLeftMouseButtonDown)
{
DisplayFrameDetailAtMouse(InMyGeometry,InMouseEvent);
}
return FReply::Handled();
}
FReply FSequencerEditTool_Movement::OnMouseButtonDown(SWidget& OwnerWidget, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
DelayedDrag.Reset();
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
DelayedDrag = FDelayedDrag_Hotspot(MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition()), EKeys::LeftMouseButton, Hotspot);
return FReply::Handled();
}
return FReply::Unhandled();
}
FReply STrackNode::BeginDrag( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
FVector2D ScreenCursorPos = MouseEvent.GetScreenSpacePosition();
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(ScreenCursorPos);
FVector2D ScreenNodePosition = MyGeometry.AbsolutePosition;// + GetOffsetRelativeToParent(MyGeometry);
bBeingDragged = true;
//void FTrackNodeDragDropOp(TSharedRef<STrackNode> TrackNode, const FVector2D &CursorPosition, const FVector2D &ScreenPositionOfNode)
return FReply::Handled().BeginDragDrop(FTrackNodeDragDropOp::New(SharedThis(this), ScreenCursorPos, ScreenNodePosition));
}
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;
}
FReply SGraphPanel::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
const FVector2D NodeAddPosition = PanelCoordToGraphCoord( MyGeometry.AbsoluteToLocal( DragDropEvent.GetScreenSpacePosition() ) );
FSlateApplication::Get().SetKeyboardFocus(AsShared(), EFocusCause::SetDirectly);
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid() || !IsEditable.Get())
{
return FReply::Unhandled();
}
if (Operation->IsOfType<FGraphEditorDragDropAction>())
{
check(GraphObj);
TSharedPtr<FGraphEditorDragDropAction> DragConn = StaticCastSharedPtr<FGraphEditorDragDropAction>(Operation);
if (DragConn.IsValid() && DragConn->IsSupportedBySchema(GraphObj->GetSchema()))
{
return DragConn->DroppedOnPanel(SharedThis(this), DragDropEvent.GetScreenSpacePosition(), NodeAddPosition, *GraphObj);
}
return FReply::Unhandled();
}
else if (Operation->IsOfType<FActorDragDropGraphEdOp>())
{
TSharedPtr<FActorDragDropGraphEdOp> ActorOp = StaticCastSharedPtr<FActorDragDropGraphEdOp>(Operation);
OnDropActor.ExecuteIfBound(ActorOp->Actors, GraphObj, NodeAddPosition);
return FReply::Handled();
}
else if (Operation->IsOfType<FLevelDragDropOp>())
{
TSharedPtr<FLevelDragDropOp> LevelOp = StaticCastSharedPtr<FLevelDragDropOp>(Operation);
OnDropStreamingLevel.ExecuteIfBound(LevelOp->StreamingLevelsToDrop, GraphObj, NodeAddPosition);
return FReply::Handled();
}
else
{
if(GraphObj != NULL && GraphObj->GetSchema() != NULL)
{
TArray< FAssetData > DroppedAssetData = AssetUtil::ExtractAssetDataFromDrag( DragDropEvent );
if ( DroppedAssetData.Num() > 0 )
{
GraphObj->GetSchema()->DroppedAssetsOnGraph( DroppedAssetData, NodeAddPosition, GraphObj );
return FReply::Handled();
}
}
return FReply::Unhandled();
}
}
FSelectedKey SSection::GetKeyUnderMouse( const FVector2D& MousePosition, const FGeometry& AllottedGeometry ) const
{
UMovieSceneSection& Section = *SectionInterface->GetSectionObject();
// Search every key area until we find the one under the mouse
for( int32 KeyAreaIndex = 0; KeyAreaIndex < KeyAreas.Num(); ++KeyAreaIndex )
{
const FKeyAreaElement& Element = KeyAreas[KeyAreaIndex];
TSharedRef<IKeyArea> KeyArea = Element.KeyAreaNode.GetKeyArea( SectionIndex );
// Compute the current key area geometry
FGeometry KeyAreaGeometryPadded = GetKeyAreaGeometry( Element, AllottedGeometry );
// Is the key area under the mouse
if( KeyAreaGeometryPadded.IsUnderLocation( MousePosition ) )
{
FGeometry SectionGeometry = AllottedGeometry.MakeChild(FVector2D(SequencerSectionConstants::SectionGripSize, 0), AllottedGeometry.GetDrawSize() - FVector2D(SequencerSectionConstants::SectionGripSize*2, 0.0f));
FGeometry KeyAreaGeometry = GetKeyAreaGeometry( Element, SectionGeometry );
FVector2D LocalSpaceMousePosition = KeyAreaGeometry.AbsoluteToLocal( MousePosition );
FTimeToPixel TimeToPixelConverter = Section.IsInfinite() ?
FTimeToPixel( ParentGeometry, GetSequencer().GetViewRange()) :
FTimeToPixel( KeyAreaGeometry, TRange<float>( Section.GetStartTime(), Section.GetEndTime() ) );
// Check each key until we find one under the mouse (if any)
TArray<FKeyHandle> KeyHandles = KeyArea->GetUnsortedKeyHandles();
for( int32 KeyIndex = 0; KeyIndex < KeyHandles.Num(); ++KeyIndex )
{
FKeyHandle KeyHandle = KeyHandles[KeyIndex];
float KeyPosition = TimeToPixelConverter.TimeToPixel( KeyArea->GetKeyTime(KeyHandle) );
FGeometry KeyGeometry = KeyAreaGeometry.MakeChild(
FVector2D( KeyPosition - FMath::TruncToFloat(SequencerSectionConstants::KeySize.X/2.0f), ((KeyAreaGeometry.Size.Y*.5f)-(SequencerSectionConstants::KeySize.Y*.5f)) ),
SequencerSectionConstants::KeySize );
if( KeyGeometry.IsUnderLocation( MousePosition ) )
{
// The current key is under the mouse
return FSelectedKey( Section, KeyArea, KeyHandle );
}
}
// no key was selected in the current key area but the mouse is in the key area so it cannot possibly be in any other key area
return FSelectedKey();
}
}
// No key was selected in any key area
return FSelectedKey();
}
ETransformAction STransformHandle::ComputeActionAtLocation(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) const
{
FVector2D LocalPosition = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
FVector2D GrabOriginOffset = LocalPosition - DragOrigin;
if ( GrabOriginOffset.SizeSquared() < 36.f )
{
return ETransformAction::Primary;
}
else
{
return ETransformAction::Secondary;
}
}
void FWebBrowserWindow::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (IsValid())
{
CefMouseEvent Event;
FVector2D LocalPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
Event.x = LocalPos.X;
Event.y = LocalPos.Y;
Event.modifiers = GetCefMouseModifiers(MouseEvent);
InternalCefBrowser->GetHost()->SendMouseMoveEvent(Event, false);
}
}
CefMouseEvent FCEFWebBrowserWindow::GetCefMouseEvent(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup)
{
CefMouseEvent Event;
FVector2D LocalPos = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
if (bIsPopup)
{
LocalPos += PopupPosition;
}
Event.x = LocalPos.X;
Event.y = LocalPos.Y;
Event.modifiers = GetCefMouseModifiers(MouseEvent);
return Event;
}
FReply FTextEditHelper::OnMouseMove( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent, const TSharedRef< ITextEditorWidget >& TextEditor )
{
FReply Reply = FReply::Unhandled();
if( TextEditor->IsDragSelecting() && TextEditor->GetWidget()->HasMouseCapture() && InMouseEvent.GetCursorDelta() != FVector2D::ZeroVector )
{
TextEditor->MoveCursor( FMoveCursor::ViaScreenPointer( InMyGeometry.AbsoluteToLocal( InMouseEvent.GetScreenSpacePosition( ) ), InMyGeometry.Scale, ECursorAction::SelectText ) );
TextEditor->SetHasDragSelectedSinceFocused( true );
Reply = FReply::Handled();
}
return Reply;
}
/** Update DraggableBarIndex but seeing if the mouse is over a draggable bar */
void STrack::UpdateDraggableBarIndex( const FGeometry& MyGeometry, FVector2D CursorScreenPos )
{
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(CursorScreenPos);
DraggableBarIndex = INDEX_NONE;
for ( int32 I=0; DraggableBars.IsBound() && I < DraggableBars.Get().Num(); I++ )
{
if( FMath::Abs( DataToLocalX(DraggableBars.Get()[I], MyGeometry) - CursorPos.X ) < 10 )
{
DraggableBarIndex = I;
break;
}
}
}
FReply SVirtualJoystick::OnTouchStarted(const FGeometry& MyGeometry, const FPointerEvent& Event)
{
// UE_LOG(LogTemp, Log, TEXT("Pointer index: %d"), Event.GetPointerIndex());
FVector2D LocalCoord = MyGeometry.AbsoluteToLocal( Event.GetScreenSpacePosition() );
for (int32 ControlIndex = 0; ControlIndex < Controls.Num(); ControlIndex++)
{
FControlInfo& Control = Controls[ControlIndex];
// skip controls already in use
if (Control.CapturedPointerIndex == -1)
{
if (PositionIsInside(Control, LocalCoord, Control.InteractionSize))
{
// Align Joystick inside of Screen
AlignBoxIntoScreen(LocalCoord, Control.VisualSize, MyGeometry.Size);
Control.CapturedPointerIndex = Event.GetPointerIndex();
if (ActivationDelay == 0.f)
{
CurrentOpacity = ActiveOpacity;
if (!bPreventReCenter)
{
Control.VisualCenter = LocalCoord;
}
if (HandleTouch(ControlIndex, LocalCoord, MyGeometry.Size)) // Never fail!
{
return FReply::Handled();
}
}
else
{
Control.bNeedUpdatedCenter = true;
Control.ElapsedTime = 0.f;
Control.NextCenter = LocalCoord;
return FReply::Unhandled();
}
}
}
}
// CapturedPointerIndex[CapturedJoystick] = -1;
return FReply::Unhandled();
}
FReply SGraphPin::OnPinNameMouseDown( const FGeometry& SenderGeometry, const FPointerEvent& MouseEvent )
{
const float LocalX = SenderGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ).X;
if ((GetDirection() == EGPD_Input) || (LocalX > SenderGeometry.GetDrawSize().X * 0.5f))
{
// Right half of the output pin or all of the input pin, treat it like a connection attempt
return OnPinMouseDown(SenderGeometry, MouseEvent);
}
else
{
return FReply::Unhandled();
}
}
void SRealtimeProfilerLineGraph::DisplayFrameDetailAtMouse(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
FVector2D pressedLocation = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
float PixelDistanceBetweenPoints = ((float)InMyGeometry.Size.X/MaxFrames.Get())*Zoom;
float FrameOffset = (-Offset/Zoom)*MaxFrames.Get();
int32 FrameIndex = (pressedLocation.X/PixelDistanceBetweenPoints)+FrameOffset;
if(0 <= FrameIndex && FrameIndex < ProfileDataArray.Num())
{
TSharedPtr< FVisualizerEvent > SelectedData = ProfileDataArray.GetData()[FrameIndex];
Visualizer.Get()->DisplayFrameDetails(SelectedData);
}
}
FReply SGraphBar::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
// Translate click position from absolute to graph space
const float ClickX = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ).X;//( MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ).X / MyGeometry.Size.X ) / Zoom - Offset / Zoom;
TSharedPtr< FVisualizerEvent > SelectedEvent;
// Go through all events and check if at least one has been clicked
int32 EventIndex = INDEX_NONE;
for( EventIndex = 0; EventIndex < Events.Num(); EventIndex++ )
{
TSharedPtr< FVisualizerEvent > Event = Events[ EventIndex ];
float StartX, EndX;
if( CalculateEventGeometry( Event.Get(), MyGeometry, StartX, EndX ) )
{
if( ClickX >= StartX && ClickX < EndX )
{
// An event has been clicked, abort
SelectedEvent = Event;
Event->IsSelected = true;
break;
}
else
{
Event->IsSelected = false;
}
}
}
// Iterate over all the remaining events and mark them as not selected
for( EventIndex = EventIndex + 1; EventIndex < Events.Num(); EventIndex++ )
{
Events[ EventIndex ]->IsSelected = false;
}
// Execute OnSelectionChanged delegate
if( OnSelectionChanged.IsBound() )
{
OnSelectionChanged.ExecuteIfBound( SelectedEvent, ESelectInfo::OnMouseClick );
}
return FReply::Handled();
}
else
{
return FReply::Unhandled();
}
}
FReply FSequencerEditTool_Movement::OnMouseButtonUp(SWidget& OwnerWidget, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
DelayedDrag.Reset();
if (DragOperation.IsValid())
{
DragOperation->OnEndDrag(MouseEvent, MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition()), SequencerWidget.Pin()->GetVirtualTrackArea());
DragOperation = nullptr;
// Only return handled if we actually started a drag
return FReply::Handled().ReleaseMouseCapture();
}
return FSequencerEditTool_Default::OnMouseButtonUp(OwnerWidget, MyGeometry, MouseEvent);
}
FReply SSplitter2x2::OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
const FVector2D LocalMousePos = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
if ( bIsResizing && this->HasMouseCapture() )
{
TArray<FLayoutGeometry> LayoutChildren = ArrangeChildrenForLayout(MyGeometry);
ResizeChildren( MyGeometry, LayoutChildren, LocalMousePos );
return FReply::Handled();
}
else
{
ResizingAxis = CalculateResizingAxis( MyGeometry, LocalMousePos );
return FReply::Unhandled();
}
}
FReply SSplitter2x2::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
FReply Reply = FReply::Unhandled();
if ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
const FVector2D LocalMousePos = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
ResizingAxis = CalculateResizingAxis( MyGeometry, LocalMousePos );
if ( ResizingAxis != INDEX_NONE )
{
bIsResizing = true;
Reply = FReply::Handled().CaptureMouse( SharedThis(this) );
}
}
return Reply;
}
FReply STableViewBase::OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if( MouseEvent.IsMouseButtonDown( EKeys::RightMouseButton ) )
{
const float ScrollByAmount = MouseEvent.GetCursorDelta().Y / MyGeometry.Scale;
// If scrolling with the right mouse button, we need to remember how much we scrolled.
// If we did not scroll at all, we will bring up the context menu when the mouse is released.
AmountScrolledWhileRightMouseDown += FMath::Abs( ScrollByAmount );
// Has the mouse moved far enough with the right mouse button held down to start capturing
// the mouse and dragging the view?
if( IsRightClickScrolling() )
{
// Make sure the active timer is registered to update the inertial scroll
if (!bIsScrollingActiveTimerRegistered)
{
bIsScrollingActiveTimerRegistered = true;
RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateSP(this, &STableViewBase::UpdateInertialScroll));
}
TickScrollDelta -= ScrollByAmount;
const float AmountScrolled = this->ScrollBy( MyGeometry, -ScrollByAmount, AllowOverscroll );
FReply Reply = FReply::Handled();
// The mouse moved enough that we're now dragging the view. Capture the mouse
// so the user does not have to stay within the bounds of the list while dragging.
if(this->HasMouseCapture() == false)
{
Reply.CaptureMouse( AsShared() ).UseHighPrecisionMouseMovement( AsShared() );
SoftwareCursorPosition = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
bShowSoftwareCursor = true;
}
// Check if the mouse has moved.
if( AmountScrolled != 0 )
{
SoftwareCursorPosition.Y += ScrollByAmount;
}
return Reply;
}
}
return FReply::Unhandled();
}
FReply SPaperEditorViewport::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
const bool bIsRightMouseButtonDown = MouseEvent.IsMouseButtonDown(EKeys::RightMouseButton);
const bool bIsLeftMouseButtonDown = MouseEvent.IsMouseButtonDown(EKeys::LeftMouseButton);
if (HasMouseCapture())
{
// Track how much the mouse moved since the mouse down.
const FVector2D CursorDelta = MouseEvent.GetCursorDelta();
TotalMouseDelta += CursorDelta.Size();
if (bIsRightMouseButtonDown)
{
FReply ReplyState = FReply::Handled();
if (!CursorDelta.IsZero())
{
bShowSoftwareCursor = true;
}
bIsPanning = true;
ViewOffset -= CursorDelta / GetZoomAmount();
return ReplyState;
}
else if (bIsLeftMouseButtonDown)
{
// TSharedPtr<SNode> NodeBeingDragged = NodeUnderMousePtr.Pin();
// Update the amount to pan panel
UpdateViewOffset(MyGeometry, MouseEvent.GetScreenSpacePosition());
const bool bCursorInDeadZone = TotalMouseDelta <= FSlateApplication::Get().GetDragTriggerDistance();
{
// We are marquee selecting
const FVector2D GraphMousePos = PanelCoordToGraphCoord( MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ) );
Marquee.Rect.UpdateEndPoint(GraphMousePos);
return FReply::Handled();
}
}
}
return FReply::Unhandled();
}
