401 lines
12 KiB
C++
401 lines
12 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
|
|
#include "SGraphNodeResizable.h"
|
|
|
|
#include "EdGraph/EdGraphNode.h"
|
|
#include "Framework/Application/SlateApplication.h"
|
|
#include "GenericPlatform/ICursor.h"
|
|
#include "Input/Events.h"
|
|
#include "InputCoreTypes.h"
|
|
#include "Internationalization/Internationalization.h"
|
|
#include "Layout/Geometry.h"
|
|
#include "Math/UnrealMathUtility.h"
|
|
#include "Misc/Attribute.h"
|
|
#include "SNodePanel.h"
|
|
#include "ScopedTransaction.h"
|
|
#include "SGraphPanel.h"
|
|
#include "Widgets/SWindow.h"
|
|
|
|
namespace GraphNodeResizableDefs
|
|
{
|
|
/** Size of the hit result border for the window borders */
|
|
static const FSlateRect HitResultBorderSize( 10, 10, 10, 10 );
|
|
|
|
/** Default Title Bar Size */
|
|
static const float DefaultTitleBarHeight = 12.f;
|
|
|
|
/** Minimum size for node */
|
|
static const FDeprecateSlateVector2D MinNodeSize( 30.0f, 30.0f );
|
|
|
|
/** Maximum size for node */
|
|
static const FDeprecateSlateVector2D MaxNodeSize( 400.0f, 400.0f );
|
|
}
|
|
|
|
bool SGraphNodeResizable::InSelectionArea(EResizableWindowZone InMouseZone) const
|
|
{
|
|
return ( (InMouseZone == CRWZ_RightBorder) || (InMouseZone == CRWZ_BottomBorder) || (InMouseZone == CRWZ_BottomRightBorder) ||
|
|
(InMouseZone == CRWZ_LeftBorder) || (InMouseZone == CRWZ_TopBorder) || (InMouseZone == CRWZ_TopLeftBorder) ||
|
|
(InMouseZone == CRWZ_TopRightBorder) || (InMouseZone == CRWZ_BottomLeftBorder) );
|
|
}
|
|
|
|
void SGraphNodeResizable::OnMouseEnter( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
|
|
{
|
|
// Determine the zone the mouse is in
|
|
if( !bUserIsDragging )
|
|
{
|
|
FVector2f LocalMouseCoordinates = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
|
|
MouseZone = FindMouseZone(LocalMouseCoordinates);
|
|
SNodePanel::SNode::OnMouseEnter( MyGeometry, MouseEvent );
|
|
}
|
|
}
|
|
|
|
void SGraphNodeResizable::OnMouseLeave( const FPointerEvent& MouseEvent )
|
|
{
|
|
if( !bUserIsDragging )
|
|
{
|
|
// Reset our mouse zone
|
|
MouseZone = CRWZ_NotInWindow;
|
|
SNodePanel::SNode::OnMouseLeave( MouseEvent );
|
|
}
|
|
}
|
|
|
|
FCursorReply SGraphNodeResizable::OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) const
|
|
{
|
|
if (MouseZone == CRWZ_RightBorder || MouseZone == CRWZ_LeftBorder)
|
|
{
|
|
// right/left of node
|
|
return FCursorReply::Cursor(EMouseCursor::ResizeLeftRight);
|
|
}
|
|
else if (MouseZone == CRWZ_BottomRightBorder || MouseZone == CRWZ_TopLeftBorder)
|
|
{
|
|
// bottom right / top left hand corner
|
|
return FCursorReply::Cursor( EMouseCursor::ResizeSouthEast );
|
|
}
|
|
else if (MouseZone == CRWZ_BottomBorder || MouseZone == CRWZ_TopBorder)
|
|
{
|
|
// bottom / top of node
|
|
return FCursorReply::Cursor(EMouseCursor::ResizeUpDown);
|
|
}
|
|
else if (MouseZone == CRWZ_BottomLeftBorder || MouseZone == CRWZ_TopRightBorder)
|
|
{
|
|
// bottom left / top right hand corner
|
|
return FCursorReply::Cursor( EMouseCursor::ResizeSouthWest );
|
|
}
|
|
else if (MouseZone == CRWZ_TitleBar)
|
|
{
|
|
return FCursorReply::Cursor(EMouseCursor::CardinalCross);
|
|
}
|
|
|
|
return FCursorReply::Unhandled();
|
|
}
|
|
|
|
FReply SGraphNodeResizable::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
|
|
{
|
|
if ( InSelectionArea() && (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton) && IsEditable.Get() )
|
|
{
|
|
bUserIsDragging = true;
|
|
StoredUserSize = UserSize;
|
|
DragSize = UserSize;
|
|
//Find node anchor point
|
|
InitNodeAnchorPoint();
|
|
|
|
return FReply::Handled().CaptureMouse( SharedThis(this) );
|
|
}
|
|
else
|
|
{
|
|
return FReply::Unhandled();
|
|
}
|
|
}
|
|
|
|
FReply SGraphNodeResizable::OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
|
|
{
|
|
if ( (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton) && bUserIsDragging )
|
|
{
|
|
bUserIsDragging = false;
|
|
|
|
// Resize the node
|
|
UserSize.X = FMath::RoundToFloat(UserSize.X);
|
|
UserSize.Y = FMath::RoundToFloat(UserSize.Y);
|
|
|
|
GetNodeObj()->ResizeNode(UserSize);
|
|
|
|
// End resize transaction
|
|
ResizeTransactionPtr.Reset();
|
|
|
|
return FReply::Handled().ReleaseMouseCapture();
|
|
}
|
|
return FReply::Unhandled();
|
|
}
|
|
|
|
|
|
FReply SGraphNodeResizable::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
|
|
{
|
|
if (bUserIsDragging)
|
|
{
|
|
FVector2f GraphSpaceCoordinates = NodeCoordToGraphCoord( MouseEvent.GetScreenSpacePosition() );
|
|
FVector2f OldGraphSpaceCoordinates = NodeCoordToGraphCoord( MouseEvent.GetLastScreenSpacePosition() );
|
|
TSharedPtr<SWindow> OwnerWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
|
|
FVector2f Delta = (GraphSpaceCoordinates - OldGraphSpaceCoordinates) / (OwnerWindow.IsValid() ? OwnerWindow->GetDPIScaleFactor() : 1.0f);
|
|
|
|
|
|
//Clamp delta value based on resizing direction
|
|
if( MouseZone == CRWZ_LeftBorder || MouseZone == CRWZ_RightBorder )
|
|
{
|
|
Delta.Y = 0.0f;
|
|
}
|
|
else if( MouseZone == CRWZ_TopBorder || MouseZone == CRWZ_BottomBorder )
|
|
{
|
|
Delta.X = 0.0f;
|
|
}
|
|
|
|
//Resize node delta value
|
|
FVector2f DeltaNodeSize = Delta;
|
|
|
|
//Modify node size delta value based on resizing direction
|
|
if( (MouseZone == CRWZ_LeftBorder) || (MouseZone == CRWZ_TopBorder) || (MouseZone == CRWZ_TopLeftBorder) )
|
|
{
|
|
DeltaNodeSize = -DeltaNodeSize;
|
|
}
|
|
else if( MouseZone == CRWZ_TopRightBorder )
|
|
{
|
|
DeltaNodeSize.Y = -DeltaNodeSize.Y;
|
|
}
|
|
else if( MouseZone == CRWZ_BottomLeftBorder )
|
|
{
|
|
DeltaNodeSize.X = -DeltaNodeSize.X;
|
|
}
|
|
// Apply delta unfiltered to DragSize
|
|
DragSize.X += DeltaNodeSize.X;
|
|
DragSize.Y += DeltaNodeSize.Y;
|
|
// apply snap
|
|
const float SnapSize = static_cast<float>(SNodePanel::GetSnapGridSize());
|
|
FVector2f SnappedSize;
|
|
SnappedSize.X = SnapSize * FMath::RoundToFloat( DragSize.X/SnapSize );
|
|
SnappedSize.Y = SnapSize * FMath::RoundToFloat( DragSize.Y/SnapSize );
|
|
|
|
// Enforce min/max sizing
|
|
const FVector2f MinSize = GetNodeMinimumSize2f();
|
|
SnappedSize.X = FMath::Max( SnappedSize.X, MinSize.X );
|
|
SnappedSize.Y = FMath::Max( SnappedSize.Y, MinSize.Y );
|
|
|
|
const FVector2f MaxSize = GetNodeMaximumSize2f();
|
|
SnappedSize.X = FMath::Min( SnappedSize.X, MaxSize.X );
|
|
SnappedSize.Y = FMath::Min( SnappedSize.Y, MaxSize.Y );
|
|
|
|
FVector2f DeltaNodePos(0.0f,0.0f);
|
|
|
|
if( UserSize != SnappedSize )
|
|
{
|
|
//Modify node position (resizing top and left sides)
|
|
if( MouseZone != CRWZ_BottomBorder && MouseZone != CRWZ_RightBorder && MouseZone != CRWZ_BottomRightBorder )
|
|
{
|
|
//Delta value to move graph node position
|
|
DeltaNodePos = UserSize - SnappedSize;
|
|
|
|
//Clamp position delta based on resizing direction
|
|
if( MouseZone == CRWZ_BottomLeftBorder )
|
|
{
|
|
DeltaNodePos.Y = 0.0f;
|
|
}
|
|
else if( MouseZone == CRWZ_TopRightBorder )
|
|
{
|
|
DeltaNodePos.X = 0.0f;
|
|
}
|
|
}
|
|
UserSize = SnappedSize;
|
|
GraphNode->ResizeNode( UserSize );
|
|
DeltaNodePos = GetCorrectedNodePosition() - GetPosition2f();
|
|
}
|
|
|
|
if (!ResizeTransactionPtr.IsValid() && UserSize != StoredUserSize)
|
|
{
|
|
// Start resize transaction. The transaction is started here so all MoveTo actions are captured while empty
|
|
// transactions are not created
|
|
ResizeTransactionPtr = MakeShareable(new FScopedTransaction(NSLOCTEXT("GraphEditor", "ResizeNodeAction", "Resize Node")));
|
|
}
|
|
|
|
SGraphNode::FNodeSet NodeFilter;
|
|
SGraphNode::MoveTo( GetPosition2f() + DeltaNodePos, NodeFilter );
|
|
}
|
|
else
|
|
{
|
|
const FVector2f LocalMouseCoordinates = MyGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() );
|
|
MouseZone = FindMouseZone(LocalMouseCoordinates);
|
|
}
|
|
return SGraphNode::OnMouseMove( MyGeometry, MouseEvent );
|
|
}
|
|
|
|
void SGraphNodeResizable::InitNodeAnchorPoint()
|
|
{
|
|
NodeAnchorPoint = GetPosition2f();
|
|
|
|
if( (MouseZone == CRWZ_LeftBorder) || (MouseZone == CRWZ_TopBorder) || (MouseZone == CRWZ_TopLeftBorder) )
|
|
{
|
|
NodeAnchorPoint += UserSize;
|
|
}
|
|
else if( MouseZone == CRWZ_BottomLeftBorder )
|
|
{
|
|
NodeAnchorPoint.X += UserSize.X;
|
|
}
|
|
else if( MouseZone == CRWZ_TopRightBorder )
|
|
{
|
|
NodeAnchorPoint.Y += UserSize.Y;
|
|
}
|
|
}
|
|
|
|
|
|
UE::Slate::FDeprecateVector2DResult SGraphNodeResizable::GetCorrectedNodePosition() const
|
|
{
|
|
FVector2f CorrectedPos = NodeAnchorPoint;
|
|
|
|
if( (MouseZone == CRWZ_LeftBorder) || (MouseZone == CRWZ_TopBorder) || (MouseZone == CRWZ_TopLeftBorder) )
|
|
{
|
|
CorrectedPos -= UserSize;
|
|
}
|
|
else if( MouseZone == CRWZ_BottomLeftBorder )
|
|
{
|
|
CorrectedPos.X -= UserSize.X;
|
|
}
|
|
else if( MouseZone == CRWZ_TopRightBorder )
|
|
{
|
|
CorrectedPos.Y -= UserSize.Y;
|
|
}
|
|
|
|
return CorrectedPos;
|
|
}
|
|
SGraphNodeResizable::EResizableWindowZone SGraphNodeResizable::FindMouseZone(const FVector2f& LocalMouseCoordinates) const
|
|
{
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
return FindMouseZone(FVector2D(LocalMouseCoordinates));
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
}
|
|
|
|
SGraphNodeResizable::EResizableWindowZone SGraphNodeResizable::FindMouseZone(const FVector2D& LocalMouseCoordinates) const
|
|
{
|
|
EResizableWindowZone OutMouseZone = CRWZ_NotInWindow;
|
|
FSlateRect HitResultBorderSize = GetHitTestingBorder();
|
|
const FVector2f NodeSize = GetDesiredSize();
|
|
const FVector2f& LocalMouseCoords = UE::Slate::CastToVector2f(LocalMouseCoordinates);
|
|
const float TitleBarHeight = GetTitleBarHeight();
|
|
|
|
const float Zoom = GetOwnerPanel()->GetZoomAmount();
|
|
|
|
if (Zoom > 0.0f && Zoom < 1.0f)
|
|
{
|
|
// Scale up the hit zones when zoomed out so that they remain accessible.
|
|
const float Scale = 1.0f / Zoom;
|
|
HitResultBorderSize = FSlateRect(HitResultBorderSize.Left * Scale, HitResultBorderSize.Top * Scale, HitResultBorderSize.Right * Scale, HitResultBorderSize.Bottom * Scale);
|
|
}
|
|
|
|
// Test for hit in location of 'grab' zone
|
|
if (LocalMouseCoords.Y > (NodeSize.Y - HitResultBorderSize.Bottom))
|
|
{
|
|
OutMouseZone = CRWZ_BottomBorder;
|
|
}
|
|
else if (TitleBarHeight <= HitResultBorderSize.Top * 1.5f)
|
|
{
|
|
// Use the largest of the two hit areas.
|
|
const float LargestZone = FMath::Max(TitleBarHeight, HitResultBorderSize.Top);
|
|
|
|
// Allow half of the title bar to be treated as the top edge
|
|
// so that the title bar can still be grabbed
|
|
if (LocalMouseCoords.Y < LargestZone * 0.4)
|
|
{
|
|
OutMouseZone = CRWZ_TopBorder;
|
|
}
|
|
else if (LocalMouseCoords.Y < LargestZone)
|
|
{
|
|
OutMouseZone = CRWZ_TitleBar;
|
|
}
|
|
}
|
|
else if (LocalMouseCoords.Y <= (HitResultBorderSize.Top))
|
|
{
|
|
OutMouseZone = CRWZ_TopBorder;
|
|
}
|
|
else if (LocalMouseCoords.Y <= TitleBarHeight)
|
|
{
|
|
OutMouseZone = CRWZ_TitleBar;
|
|
}
|
|
|
|
if (LocalMouseCoords.X > (NodeSize.X - HitResultBorderSize.Right))
|
|
{
|
|
if (OutMouseZone == CRWZ_BottomBorder)
|
|
{
|
|
OutMouseZone = CRWZ_BottomRightBorder;
|
|
}
|
|
else if (OutMouseZone == CRWZ_TopBorder)
|
|
{
|
|
OutMouseZone = CRWZ_TopRightBorder;
|
|
}
|
|
else
|
|
{
|
|
OutMouseZone = CRWZ_RightBorder;
|
|
}
|
|
}
|
|
else if (LocalMouseCoords.X <= HitResultBorderSize.Left)
|
|
{
|
|
if (OutMouseZone == CRWZ_TopBorder)
|
|
{
|
|
OutMouseZone = CRWZ_TopLeftBorder;
|
|
}
|
|
else if (OutMouseZone == CRWZ_BottomBorder)
|
|
{
|
|
OutMouseZone = CRWZ_BottomLeftBorder;
|
|
}
|
|
else
|
|
{
|
|
OutMouseZone = CRWZ_LeftBorder;
|
|
}
|
|
}
|
|
|
|
// Test for hit on rest of frame
|
|
if (OutMouseZone == CRWZ_NotInWindow)
|
|
{
|
|
if (LocalMouseCoords.Y > HitResultBorderSize.Top)
|
|
{
|
|
OutMouseZone = CRWZ_InWindow;
|
|
}
|
|
else if (LocalMouseCoords.X > HitResultBorderSize.Left)
|
|
{
|
|
OutMouseZone = CRWZ_InWindow;
|
|
}
|
|
}
|
|
return OutMouseZone;
|
|
}
|
|
|
|
float SGraphNodeResizable::GetTitleBarHeight() const
|
|
{
|
|
// this can probably just be SGraphNode::GetTitleRect().Height()
|
|
return GraphNodeResizableDefs::DefaultTitleBarHeight;
|
|
}
|
|
|
|
FVector2D SGraphNodeResizable::GetNodeMinimumSize() const
|
|
{
|
|
return FVector2D(GraphNodeResizableDefs::MinNodeSize);
|
|
}
|
|
|
|
FVector2f SGraphNodeResizable::GetNodeMinimumSize2f() const
|
|
{
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
return UE::Slate::CastToVector2f(GetNodeMinimumSize());
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
}
|
|
|
|
FVector2D SGraphNodeResizable::GetNodeMaximumSize() const
|
|
{
|
|
return GraphNodeResizableDefs::MaxNodeSize;
|
|
}
|
|
|
|
FVector2f SGraphNodeResizable::GetNodeMaximumSize2f() const
|
|
{
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
return UE::Slate::CastToVector2f(GetNodeMaximumSize());
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
}
|
|
|
|
FSlateRect SGraphNodeResizable::GetHitTestingBorder() const
|
|
{
|
|
return GraphNodeResizableDefs::HitResultBorderSize;
|
|
}
|