FReply SAssetTreeItem::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
bDraggedOver = false;
if ( IsValidAssetPath() )
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return FReply::Unhandled();
}
if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>( DragDropEvent.GetOperation() );
OnAssetsDragDropped.ExecuteIfBound(DragDropOp->AssetData, TreeItem.Pin());
return FReply::Handled();
}
else if (Operation->IsOfType<FAssetPathDragDropOp>())
{
TSharedPtr<FAssetPathDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetPathDragDropOp>( DragDropEvent.GetOperation() );
bool bCanDrop = DragDropOp->PathNames.Num() > 0;
if ( DragDropOp->PathNames.Num() == 1 && DragDropOp->PathNames[0] == TreeItem.Pin()->FolderPath )
{
// You can't drop a single folder onto itself
bCanDrop = false;
}
if ( bCanDrop )
{
OnPathsDragDropped.ExecuteIfBound(DragDropOp->PathNames, TreeItem.Pin());
}
return FReply::Handled();
}
else if (Operation->IsOfType<FExternalDragOperation>())
{
TSharedPtr<FExternalDragOperation> DragDropOp = StaticCastSharedPtr<FExternalDragOperation>( DragDropEvent.GetOperation() );
bool bCanDrop = DragDropOp->HasFiles();
if ( bCanDrop )
{
OnFilesDragDropped.ExecuteIfBound(DragDropOp->GetFiles(), TreeItem.Pin());
}
return FReply::Handled();
}
}
return FReply::Unhandled();
}
FReply SFlipbookKeyframeWidget::OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
bool bWasDropHandled = false;
UPaperFlipbook* Flipbook = FlipbookBeingEdited.Get();
if ((Flipbook != nullptr) && Flipbook->IsValidKeyFrameIndex(FrameIndex))
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
const auto& AssetDragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
//@TODO: Handle asset inserts
// OnAssetsDropped(*AssetDragDropOp);
// bWasDropHandled = true;
}
else if (Operation->IsOfType<FFlipbookKeyFrameDragDropOp>())
{
const auto& FrameDragDropOp = StaticCastSharedPtr<FFlipbookKeyFrameDragDropOp>(Operation);
FrameDragDropOp->InsertInFlipbook(Flipbook, FrameIndex);
bWasDropHandled = true;
}
}
return bWasDropHandled ? FReply::Handled() : FReply::Unhandled();
}
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 SDockingArea::OnUserAttemptingDock( SDockingNode::RelativeDirection Direction, const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
if (Direction == Center)
{
//check(Children.Num() <= 1);
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>(DragDropEvent.GetOperation());
TSharedRef<SDockingTabStack> NewStack = SNew(SDockingTabStack, FTabManager::NewStack());
AddChildNode( NewStack );
NewStack->OpenTab( DragDropOperation->GetTabBeingDragged().ToSharedRef() );
}
else
{
DockFromOutside( Direction, DragDropEvent );
}
return FReply::Handled();
}
else
{
return FReply::Unhandled();
}
}
FReply SDockingTabWell::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>( DragDropEvent.GetOperation().ToSharedRef() ) )
{
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>( DragDropEvent.GetOperation() );
if (DragDropOperation->GetTabBeingDragged()->CanDockInNode(ParentTabStackPtr.Pin().ToSharedRef(), SDockTab::DockingViaTabWell))
{
if ( ensure( TabBeingDraggedPtr.IsValid() ) )
{
// We dropped a Tab into this TabWell.
// Figure out where in this TabWell to drop the Tab.
const float ChildWidth = ComputeChildSize(MyGeometry).X;
const TSharedRef<SDockTab> TabBeingDragged = TabBeingDraggedPtr.Pin().ToSharedRef();
const float ChildWidthWithOverlap = ChildWidth - TabBeingDragged->GetOverlapWidth();
const float DraggedChildCenter = ChildBeingDraggedOffset + ChildWidth / 2;
const int32 DropLocationIndex = FMath::Clamp( static_cast<int32>(DraggedChildCenter/ChildWidthWithOverlap), 0, Tabs.Num() );
ensure( DragDropOperation->GetTabBeingDragged().ToSharedRef() == TabBeingDragged );
// Actually insert the new tab.
ParentTabStackPtr.Pin()->OpenTab(TabBeingDragged, DropLocationIndex);
// We are no longer dragging a tab.
TabBeingDraggedPtr.Reset();
// We knew how to handled this drop operation!
return FReply::Handled();
}
}
}
// Someone just dropped something in here, but we have no idea what to do with it.
return FReply::Unhandled();
}
FReply SGraphPin::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
TSharedPtr<SGraphNode> NodeWidget = OwnerNodePtr.Pin();
bool bReadOnly = NodeWidget.IsValid() ? !NodeWidget->IsNodeEditable() : false;
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid() || bReadOnly)
{
return FReply::Unhandled();
}
// Is someone dropping a connection onto this pin?
if (Operation->IsOfType<FGraphEditorDragDropAction>())
{
TSharedPtr<FGraphEditorDragDropAction> DragConnectionOp = StaticCastSharedPtr<FGraphEditorDragDropAction>(Operation);
FVector2D NodeAddPosition = FVector2D::ZeroVector;
TSharedPtr<SGraphNode> OwnerNode = OwnerNodePtr.Pin();
if (OwnerNode.IsValid())
{
NodeAddPosition = OwnerNode->GetPosition() + MyGeometry.Position;
//Don't have access to bounding information for node, using fixed offet that should work for most cases.
const float FixedOffset = 200.0f;
//Line it up vertically with pin
NodeAddPosition.Y += MyGeometry.Size.Y;
if(GetDirection() == EEdGraphPinDirection::EGPD_Input)
{
//left side just offset by fixed amount
//@TODO: knowing the width of the node we are about to create would allow us to line this up more precisely,
// but this information is not available currently
NodeAddPosition.X -= FixedOffset;
}
else
{
//right side we need the width of the pin + fixed amount because our reference position is the upper left corner of pin(which is variable length)
NodeAddPosition.X += MyGeometry.Size.X + FixedOffset;
}
}
return DragConnectionOp->DroppedOnPin(DragDropEvent.GetScreenSpacePosition(), NodeAddPosition);
}
// handle dropping an asset on the pin
else if (Operation->IsOfType<FAssetDragDropOp>() && NodeWidget.IsValid())
{
UEdGraphNode* Node = NodeWidget->GetNodeObj();
if(Node != NULL && Node->GetSchema() != NULL)
{
TSharedPtr<FAssetDragDropOp> AssetOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
Node->GetSchema()->DroppedAssetsOnPin(AssetOp->AssetData, DragDropEvent.GetScreenSpacePosition(), GraphPinObj);
}
return FReply::Handled();
}
return FReply::Unhandled();
}
void SDockingArea::OnDragLeave( const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
HideCross();
}
}
FReply SFlipbookTimeline::OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
bool bWasDropHandled = false;
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
const auto& AssetDragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
OnAssetsDropped(*AssetDragDropOp);
bWasDropHandled = true;
}
else if (Operation->IsOfType<FFlipbookKeyFrameDragDropOp>())
{
const auto& FrameDragDropOp = StaticCastSharedPtr<FFlipbookKeyFrameDragDropOp>(Operation);
if (UPaperFlipbook* ThisFlipbook = FlipbookBeingEdited.Get())
{
FrameDragDropOp->AppendToFlipbook(ThisFlipbook);
bWasDropHandled = true;
}
}
return bWasDropHandled ? FReply::Handled() : FReply::Unhandled();
}
FReply SDockingArea::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
HideCross();
}
return FReply::Unhandled();
}
FReply SAssetTreeItem::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if (ValidateDragDrop(MyGeometry, DragDropEvent, bDraggedOver)) // updates bDraggedOver
{
bDraggedOver = false;
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return FReply::Unhandled();
}
if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>( DragDropEvent.GetOperation() );
OnAssetsDragDropped.ExecuteIfBound(DragDropOp->AssetData, TreeItem.Pin());
return FReply::Handled();
}
else if (Operation->IsOfType<FAssetPathDragDropOp>())
{
TSharedPtr<FAssetPathDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetPathDragDropOp>( DragDropEvent.GetOperation() );
OnPathsDragDropped.ExecuteIfBound(DragDropOp->PathNames, TreeItem.Pin());
return FReply::Handled();
}
else if (Operation->IsOfType<FExternalDragOperation>())
{
TSharedPtr<FExternalDragOperation> DragDropOp = StaticCastSharedPtr<FExternalDragOperation>( DragDropEvent.GetOperation() );
OnFilesDragDropped.ExecuteIfBound(DragDropOp->GetFiles(), TreeItem.Pin());
return FReply::Handled();
}
}
if (bDraggedOver)
{
// We were able to handle this operation, but could not due to another error - still report this drop as handled so it doesn't fall through to other widgets
bDraggedOver = false;
return FReply::Handled();
}
return FReply::Unhandled();
}
// drag drop relationship
FReply STrack::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(DragDropEvent.GetScreenSpacePosition());
float CusorDataPos = LocalToDataX(CursorPos.X, MyGeometry);
// Handle TrackNodes that were dropped
if ( DragDrop::IsTypeMatch<FTrackNodeDragDropOp>( DragDropEvent.GetOperation() ) )
{
TSharedPtr<FTrackNodeDragDropOp> DragDropOp = StaticCastSharedPtr<FTrackNodeDragDropOp>(DragDropEvent.GetOperation());
TSharedPtr<STrackNode> TrackNode = DragDropOp->OriginalTrackNode.Pin();
float DataPos = GetNodeDragDropDataPos(MyGeometry, DragDropEvent);
TrackNode->OnTrackNodeDragged.ExecuteIfBound( DataPos );
TrackNode->OnTrackNodeDropped.ExecuteIfBound();
}
// Call delegate to handle anything else
OnTrackDragDrop.ExecuteIfBound( DragDropEvent.GetOperation(), CusorDataPos );
return FReply::Unhandled();
}
void SDockingArea::OnDragEnter( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>(DragDropEvent.GetOperation());
if ( DragDropOperation->GetTabBeingDragged()->CanDockInNode(SharedThis(this), SDockTab::DockingViaTarget) )
{
ShowCross();
}
}
}
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();
}
}
FReply STrack::OnDragOver( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
// Handle TrackNodes that were dropped
if ( DragDrop::IsTypeMatch<FTrackNodeDragDropOp>( DragDropEvent.GetOperation() ) )
{
TSharedPtr<FTrackNodeDragDropOp> DragDropOp = StaticCastSharedPtr<FTrackNodeDragDropOp>(DragDropEvent.GetOperation());
TSharedPtr<STrackNode> TrackNode = DragDropOp->OriginalTrackNode.Pin();
float DataPos = GetNodeDragDropDataPos(MyGeometry, DragDropEvent);
TrackNode->OnTrackNodeDragged.ExecuteIfBound( DataPos );
}
return FReply::Unhandled();
}
void SFlipbookTimeline::OnDragLeave(const FDragDropEvent& DragDropEvent)
{
SCompoundWidget::OnDragLeave(DragDropEvent);
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
}
else if (Operation->IsOfType<FFlipbookKeyFrameDragDropOp>())
{
const auto& FrameDragDropOp = StaticCastSharedPtr<FFlipbookKeyFrameDragDropOp>(Operation);
FrameDragDropOp->SetCanDropHere(false);
}
}
void SAssetTreeItem::OnDragEnter( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if ( IsValidAssetPath() )
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return;
}
if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
bool bCanDrop = DragDropOp->AssetData.Num() > 0;
if (bCanDrop)
{
DragDropOp->SetToolTip( LOCTEXT( "OnDragAssetsOverFolder", "Move or Copy Asset(s)" ), FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK")) );
bDraggedOver = true;
}
}
else if (Operation->IsOfType<FAssetPathDragDropOp>())
{
TSharedPtr<FAssetPathDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetPathDragDropOp>(Operation);
bool bCanDrop = DragDropOp->PathNames.Num() > 0;
if ( DragDropOp->PathNames.Num() == 1 && DragDropOp->PathNames[0] == TreeItem.Pin()->FolderPath )
{
// You can't drop a single folder onto itself
bCanDrop = false;
}
if (bCanDrop)
{
bDraggedOver = true;
}
}
else if (Operation->IsOfType<FExternalDragOperation>())
{
TSharedPtr<FExternalDragOperation> DragDropOp = StaticCastSharedPtr<FExternalDragOperation>(Operation);
bool bCanDrop = DragDropOp->HasFiles();
if (bCanDrop)
{
bDraggedOver = true;
}
}
}
}
FReply SDockingTabWell::OnDragOver( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>( DragDropEvent.GetOperation() );
if (DragDropOperation->GetTabBeingDragged()->CanDockInNode(ParentTabStackPtr.Pin().ToSharedRef(), SDockTab::DockingViaTabWell))
{
// We are dragging the tab through a TabWell.
// Update the position of the Tab that we are dragging in the panel.
this->ChildBeingDraggedOffset = ComputeDraggedTabOffset(MyGeometry, DragDropEvent, TabGrabOffsetFraction);
return FReply::Handled();
}
}
return FReply::Unhandled();
}
void SCollectionTreeItem::OnDragLeave( const FDragDropEvent& DragDropEvent )
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (Operation.IsValid())
{
Operation->SetCursorOverride(TOptional<EMouseCursor::Type>());
if (Operation->IsOfType<FCollectionDragDropOp>() || Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FDecoratedDragDropOp> DragDropOp = StaticCastSharedPtr<FDecoratedDragDropOp>(Operation);
DragDropOp->ResetToDefaultToolTip();
}
}
bDraggedOver = false;
}
FReply SDropTarget::OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
const bool bCurrentbAllowDrop = bAllowDrop;
// We've dropped an asset so we are no longer being dragged over
bIsDragEventRecognized = false;
bIsDragOver = false;
bAllowDrop = false;
// if we allow drop, call a delegate to handle the drop
if ( bCurrentbAllowDrop )
{
if ( DroppedEvent.IsBound() )
{
return DroppedEvent.Execute(DragDropEvent.GetOperation());
}
}
return FReply::Handled();
}
void SGraphPin::OnDragEnter( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return;
}
// Is someone dragging a connection?
if (Operation->IsOfType<FGraphEditorDragDropAction>())
{
// Ensure that the pin is valid before using it
if(GraphPinObj != NULL && GraphPinObj->GetOuter() != NULL && GraphPinObj->GetOuter()->IsA(UEdGraphNode::StaticClass()))
{
// Inform the Drag and Drop operation that we are hovering over this pin.
TSharedPtr<FGraphEditorDragDropAction> DragConnectionOp = StaticCastSharedPtr<FGraphEditorDragDropAction>(Operation);
DragConnectionOp->SetHoveredPin(GraphPinObj);
}
// Pins treat being dragged over the same as being hovered outside of drag and drop if they know how to respond to the drag action.
SBorder::OnMouseEnter( MyGeometry, DragDropEvent );
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<SGraphNode> NodeWidget = OwnerNodePtr.Pin();
if (NodeWidget.IsValid())
{
UEdGraphNode* Node = NodeWidget->GetNodeObj();
if(Node != NULL && Node->GetSchema() != NULL)
{
TSharedPtr<FAssetDragDropOp> AssetOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
bool bOkIcon = false;
FString TooltipText;
Node->GetSchema()->GetAssetsPinHoverMessage(AssetOp->AssetData, GraphPinObj, TooltipText, bOkIcon);
const FSlateBrush* TooltipIcon = bOkIcon ? FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK")) : FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));;
AssetOp->SetToolTip(FText::FromString(TooltipText), TooltipIcon);
}
}
}
}
void SDockingTabWell::OnDragEnter( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>(DragDropEvent.GetOperation());
if (DragDropOperation->GetTabBeingDragged()->CanDockInNode(ParentTabStackPtr.Pin().ToSharedRef(), SDockTab::DockingViaTabWell))
{
// The user dragged a tab into this TabWell.
// Update the state of the DragDropOperation to reflect this change.
DragDropOperation->OnTabWellEntered( SharedThis(this) );
// Preview the position of the tab in the TabWell
this->TabBeingDraggedPtr = DragDropOperation->GetTabBeingDragged();
this->TabGrabOffsetFraction = DragDropOperation->GetTabGrabOffsetFraction();
// The user should see the contents of the tab that we're dragging.
ParentTabStackPtr.Pin()->SetNodeContent(DragDropOperation->GetTabBeingDragged()->GetContent(), SNullWidget::NullWidget, SNullWidget::NullWidget);
}
}
}
void SDockingTabWell::OnDragLeave( const FDragDropEvent& DragDropEvent )
{
if ( DragDrop::IsTypeMatch<FDockingDragOperation>(DragDropEvent.GetOperation()) )
{
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>( DragDropEvent.GetOperation() );
// Check for TabBeingDraggedPtr validity as it may no longer be valid when dragging tabs in game
if (this->TabBeingDraggedPtr.IsValid() && DragDropOperation->GetTabBeingDragged()->CanDockInNode(ParentTabStackPtr.Pin().ToSharedRef(), SDockTab::DockingViaTabWell))
{
// Update the DragAndDrop operation based on this change.
const int32 LastForegroundTabIndex = Tabs.Find(this->TabBeingDraggedPtr.Pin().ToSharedRef());
// The user is pulling a tab out of this TabWell.
this->TabBeingDraggedPtr.Pin()->SetParent();
TSharedPtr<SDockingTabStack> ParentDockNode = ParentTabStackPtr.Pin();
// We are no longer dragging a tab in this tab well, so stop
// showing it in the TabWell.
this->TabBeingDraggedPtr.Reset();
// Also stop showing its content; switch to the last tab that was active.
BringTabToFront( FMath::Max(LastForegroundTabIndex-1, 0) );
// We may have removed the last tab that this DockNode had.
if (Tabs.Num() == 0 )
{
// Let the DockNode know that it is no longer needed.
ParentDockNode->OnLastTabRemoved();
}
GetDockArea()->CleanUp( SDockingNode::TabRemoval_DraggedOut );
const FGeometry& DockNodeGeometry = ParentDockNode->GetTabStackGeometry();
DragDropOperation->OnTabWellLeft( SharedThis(this), DockNodeGeometry );
}
}
}
void SGraphPin::OnDragLeave( const FDragDropEvent& DragDropEvent )
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return;
}
// Is someone dragging a connection?
if (Operation->IsOfType<FGraphEditorDragDropAction>())
{
// Inform the Drag and Drop operation that we are not hovering any pins
TSharedPtr<FGraphEditorDragDropAction> DragConnectionOp = StaticCastSharedPtr<FGraphEditorDragDropAction>(Operation);
DragConnectionOp->SetHoveredPin(nullptr);
SBorder::OnMouseLeave(DragDropEvent);
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> AssetOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
AssetOp->ResetToDefaultToolTip();
}
}
void SDockingArea::DockFromOutside(SDockingNode::RelativeDirection Direction, const FDragDropEvent& DragDropEvent)
{
TSharedPtr<FDockingDragOperation> DragDropOperation = StaticCastSharedPtr<FDockingDragOperation>(DragDropEvent.GetOperation());
//
// Dock from outside.
//
const bool bDirectionMatches = DoesDirectionMatchOrientation( Direction, this->Splitter->GetOrientation() );
if (!bDirectionMatches && Children.Num() > 1)
{
// We have multiple children, but the user wants to add a new node that's perpendicular to their orientation.
// We need to nest our children into a child splitter so that we can re-orient ourselves.
{
// Create a new, re-oriented splitter and copy all the children into it.
TSharedRef<SDockingSplitter> NewSplitter = SNew(SDockingSplitter, FTabManager::NewSplitter()->SetOrientation(Splitter->GetOrientation()) );
for( int32 ChildIndex=0; ChildIndex < Children.Num(); ++ChildIndex )
{
NewSplitter->AddChildNode( Children[ChildIndex], INDEX_NONE );
}
// Remove all our children.
while( Children.Num() > 0 )
{
RemoveChildAt(Children.Num()-1);
}
AddChildNode( NewSplitter );
}
// Re-orient ourselves
const EOrientation NewOrientation = (this->Splitter->GetOrientation() == Orient_Horizontal)
? Orient_Vertical
: Orient_Horizontal;
this->SetOrientation( NewOrientation );
}
// Add the new node.
{
TSharedRef<SDockingTabStack> NewStack = SNew(SDockingTabStack, FTabManager::NewStack());
if ( Direction == LeftOf || Direction == Above )
{
this->PlaceNode( NewStack, Direction, Children[0] );
}
else
{
this->PlaceNode( NewStack, Direction, Children.Last() );
}
NewStack->OpenTab( DragDropOperation->GetTabBeingDragged().ToSharedRef() );
}
HideCross();
}
TArray<FAssetData> ExtractAssetDataFromDrag(const FDragDropEvent &DragDropEvent)
{
return ExtractAssetDataFromDrag(DragDropEvent.GetOperation());
}
FVector2D STrackNode::GetDragDropScreenSpacePosition(const FGeometry& ParentAllottedGeometry, const FDragDropEvent& DragDropEvent) const
{
FVector2D DragDropPos = DragDropEvent.GetScreenSpacePosition();
TSharedPtr<FTrackNodeDragDropOp> DragDropOp = StaticCastSharedPtr<FTrackNodeDragDropOp>(DragDropEvent.GetOperation());
if(DragDropOp.IsValid())
{
DragDropPos += DragDropOp->Offset;
}
if(bCenterOnPosition)
{
// Correct for center-on-position offset
FVector2D Size = GetSizeRelativeToParent(ParentAllottedGeometry);
DragDropPos.X += Size.X/2.f;
}
return DragDropPos;
}
float STrack::GetNodeDragDropDataPos( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
float DataPos = 0.f;
TSharedPtr<FTrackNodeDragDropOp> DragDropOp = StaticCastSharedPtr<FTrackNodeDragDropOp>(DragDropEvent.GetOperation());
if(DragDropOp.IsValid())
{
TSharedPtr<STrackNode> TrackNode = DragDropOp->OriginalTrackNode.Pin();
if(TrackNode.IsValid())
{
FVector2D CursorPos = MyGeometry.AbsoluteToLocal(TrackNode->GetDragDropScreenSpacePosition(MyGeometry, DragDropEvent));
DataPos = LocalToDataX(CursorPos.X, MyGeometry);
if(TrackNode->SnapToDragBars())
{
float OriginalX = DataPos;
DataPos = GetSnappedPosForLocalPos(MyGeometry, CursorPos.X);
TrackNode->OnSnapNodeDataPosition(OriginalX, DataPos);
}
}
}
return DataPos;
}
void SMultiBoxWidget::OnCustomCommandDragged( TSharedRef<const FMultiBlock> MultiBlock, const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if( MultiBlock != DragPreview.PreviewBlock && MultiBox->IsInEditMode() )
{
TSharedPtr<FUICommandDragDropOp> DragDropContent = StaticCastSharedPtr<FUICommandDragDropOp>( DragDropEvent.GetOperation() );
UpdateDropAreaPreviewBlock( MultiBlock, DragDropContent, MyGeometry, DragDropEvent.GetScreenSpacePosition() );
}
}
FReply SDropTarget::OnDragOver(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
// Handle the reply if we are allowed to drop, otherwise do not handle it.
return AllowDrop(DragDropEvent.GetOperation()) ? FReply::Handled() : FReply::Unhandled();
}