void UEdGraphSchema::TrySetDefaultText(UEdGraphPin& InPin, const FText& InNewDefaultText) const
{
if(InNewDefaultText.IsEmpty())
{
InPin.DefaultTextValue = InNewDefaultText;
}
else
{
#if WITH_EDITOR
if(InNewDefaultText.IsCultureInvariant())
{
InPin.DefaultTextValue = InNewDefaultText;
}
else
{
InPin.DefaultTextValue = FText::ChangeKey(TEXT(""), InPin.GetOwningNode()->NodeGuid.ToString() + TEXT("_") + InPin.PinName, InNewDefaultText);
}
#endif
}
#if WITH_EDITOR
UEdGraphNode* Node = InPin.GetOwningNode();
check(Node);
Node->PinDefaultValueChanged(&InPin);
#endif //#if WITH_EDITOR
}
void UEdGraphSchema::BreakPinLinks(UEdGraphPin& TargetPin, bool bSendsNodeNotifcation) const
{
#if WITH_EDITOR
// Copy the old pin links
TArray<class UEdGraphPin*> OldLinkedTo(TargetPin.LinkedTo);
#endif
TargetPin.BreakAllPinLinks();
#if WITH_EDITOR
TSet<UEdGraphNode*> NodeList;
// Notify this node
TargetPin.GetOwningNode()->PinConnectionListChanged(&TargetPin);
NodeList.Add(TargetPin.GetOwningNode());
// As well as all other nodes that were connected
for (TArray<UEdGraphPin*>::TIterator PinIt(OldLinkedTo); PinIt; ++PinIt)
{
UEdGraphPin* OtherPin = *PinIt;
UEdGraphNode* OtherNode = OtherPin->GetOwningNode();
OtherNode->PinConnectionListChanged(OtherPin);
NodeList.Add(OtherNode);
}
if (bSendsNodeNotifcation)
{
// Send all nodes that received a new pin connection a notification
for (auto It = NodeList.CreateConstIterator(); It; ++It)
{
UEdGraphNode* Node = (*It);
Node->NodeConnectionListChanged();
}
}
#endif //#if WITH_EDITOR
}
// Reconcile other pin links:
// - Links between nodes within the copied set are fine
// - Links to nodes that were not copied need to be fixed up if the copy-paste was in the same graph or broken completely
// Call PostPasteNode on each node
void FEdGraphUtilities::PostProcessPastedNodes(TSet<UEdGraphNode*>& SpawnedNodes)
{
// Run thru and fix up the node's pin links; they may point to invalid pins if the paste was to another graph
for (TSet<UEdGraphNode*>::TIterator It(SpawnedNodes); It; ++It)
{
UEdGraphNode* Node = *It;
UEdGraph* CurrentGraph = Node->GetGraph();
for (int32 PinIndex = 0; PinIndex < Node->Pins.Num(); ++PinIndex)
{
UEdGraphPin* ThisPin = Node->Pins[PinIndex];
for (int32 LinkIndex = 0; LinkIndex < ThisPin->LinkedTo.Num(); )
{
UEdGraphPin* OtherPin = ThisPin->LinkedTo[LinkIndex];
if (OtherPin == NULL)
{
// Totally bogus link
ThisPin->LinkedTo.RemoveAtSwap(LinkIndex);
}
else if (!SpawnedNodes.Contains(OtherPin->GetOwningNode()))
{
// It's a link across the selection set, so it should be broken
OtherPin->LinkedTo.RemoveSwap(ThisPin);
ThisPin->LinkedTo.RemoveAtSwap(LinkIndex);
}
else if (!OtherPin->LinkedTo.Contains(ThisPin))
{
// The link needs to be reciprocal
check(OtherPin->GetOwningNode()->GetGraph() == CurrentGraph);
OtherPin->LinkedTo.Add(ThisPin);
++LinkIndex;
}
else
{
// Everything seems fine but sanity check the graph
check(OtherPin->GetOwningNode()->GetGraph() == CurrentGraph);
++LinkIndex;
}
}
}
}
// Give every node a chance to deep copy associated resources, etc...
for (TSet<UEdGraphNode*>::TIterator It(SpawnedNodes); It; ++It)
{
UEdGraphNode* Node = *It;
Node->PostPasteNode();
Node->ReconstructNode();
// Ensure we have RF_Transactional set on all pasted nodes, as its not copied in the T3D format
Node->SetFlags(RF_Transactional);
}
}
void FSoundCueEditor::DeleteInput()
{
UEdGraphPin* SelectedPin = SoundCueGraphEditor->GetGraphPinForMenu();
USoundCueGraphNode* SelectedNode = Cast<USoundCueGraphNode>(SelectedPin->GetOwningNode());
if (SelectedNode && SelectedNode == SelectedPin->GetOwningNode())
{
SelectedNode->RemoveInputPin(SelectedPin);
}
}
FPinConnectionResponse UEdGraphSchema::MovePinLinks(UEdGraphPin& MoveFromPin, UEdGraphPin& MoveToPin, bool bIsIntermediateMove) const
{
#if WITH_EDITOR
ensureMsg(bIsIntermediateMove || !MoveToPin.GetOwningNode()->GetGraph()->HasAnyFlags(RF_Transient),
TEXT("When moving to an Intermediate pin, use FKismetCompilerContext::MovePinLinksToIntermediate() instead of UEdGraphSchema::MovePinLinks()"));
#endif // #if WITH_EDITOR
FPinConnectionResponse FinalResponse = FPinConnectionResponse(CONNECT_RESPONSE_MAKE, TEXT(""));
// First copy the current set of links
TArray<UEdGraphPin*> CurrentLinks = MoveFromPin.LinkedTo;
// Then break all links at pin we are moving from
MoveFromPin.BreakAllPinLinks();
// Try and make each new connection
for (int32 i=0; i<CurrentLinks.Num(); i++)
{
UEdGraphPin* NewLink = CurrentLinks[i];
FPinConnectionResponse Response = CanCreateConnection(&MoveToPin, NewLink);
if(Response.CanSafeConnect())
{
MoveToPin.MakeLinkTo(NewLink);
}
else
{
FinalResponse = Response;
}
}
// Move over the default values
MoveToPin.DefaultValue = MoveFromPin.DefaultValue;
MoveToPin.DefaultObject = MoveFromPin.DefaultObject;
MoveToPin.DefaultTextValue = MoveFromPin.DefaultTextValue;
return FinalResponse;
}
FPinConnectionResponse UEdGraphSchema::CopyPinLinks(UEdGraphPin& CopyFromPin, UEdGraphPin& CopyToPin, bool bIsIntermediateCopy) const
{
#if WITH_EDITOR
ensureMsg(bIsIntermediateCopy || !CopyToPin.GetOwningNode()->GetGraph()->HasAnyFlags(RF_Transient),
TEXT("When copying to an Intermediate pin, use FKismetCompilerContext::CopyPinLinksToIntermediate() instead of UEdGraphSchema::CopyPinLinks()"));
#endif // #if WITH_EDITOR
FPinConnectionResponse FinalResponse = FPinConnectionResponse(CONNECT_RESPONSE_MAKE, TEXT(""));
for (int32 i=0; i<CopyFromPin.LinkedTo.Num(); i++)
{
UEdGraphPin* NewLink = CopyFromPin.LinkedTo[i];
FPinConnectionResponse Response = CanCreateConnection(&CopyToPin, NewLink);
if (Response.CanSafeConnect())
{
CopyToPin.MakeLinkTo(NewLink);
}
else
{
FinalResponse = Response;
}
}
CopyToPin.DefaultValue = CopyFromPin.DefaultValue;
CopyToPin.DefaultObject = CopyFromPin.DefaultObject;
CopyToPin.DefaultTextValue = CopyFromPin.DefaultTextValue;
return FinalResponse;
}
void USoundCueGraphNode_Base::InsertNewNode(UEdGraphPin* FromPin, UEdGraphPin* NewLinkPin, TSet<UEdGraphNode*>& OutNodeList)
{
const USoundCueGraphSchema* Schema = CastChecked<USoundCueGraphSchema>(GetSchema());
// The pin we are creating from already has a connection that needs to be broken. We want to "insert" the new node in between, so that the output of the new node is hooked up too
UEdGraphPin* OldLinkedPin = FromPin->LinkedTo[0];
check(OldLinkedPin);
FromPin->BreakAllPinLinks();
// Hook up the old linked pin to the first valid output pin on the new node
for (int32 OutpinPinIdx=0; OutpinPinIdx<Pins.Num(); OutpinPinIdx++)
{
UEdGraphPin* OutputExecPin = Pins[OutpinPinIdx];
check(OutputExecPin);
if (ECanCreateConnectionResponse::CONNECT_RESPONSE_MAKE == Schema->CanCreateConnection(OldLinkedPin, OutputExecPin).Response)
{
if (Schema->TryCreateConnection(OldLinkedPin, OutputExecPin))
{
OutNodeList.Add(OldLinkedPin->GetOwningNode());
OutNodeList.Add(this);
}
break;
}
}
if (Schema->TryCreateConnection(FromPin, NewLinkPin))
{
OutNodeList.Add(FromPin->GetOwningNode());
OutNodeList.Add(this);
}
}
bool SGraphPin::TryHandlePinConnection(SGraphPin& OtherSPin)
{
UEdGraphPin* PinA = GetPinObj();
UEdGraphPin* PinB = OtherSPin.GetPinObj();
UEdGraph* MyGraphObj = PinA->GetOwningNode()->GetGraph();
return MyGraphObj->GetSchema()->TryCreateConnection(PinA, PinB);
}
void USoundCueGraphNode_Base::ReconstructNode()
{
// Break any links to 'orphan' pins
for (int32 PinIndex = 0; PinIndex < Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Pins[PinIndex];
TArray<class UEdGraphPin*>& LinkedToRef = Pin->LinkedTo;
for (int32 LinkIdx=0; LinkIdx < LinkedToRef.Num(); LinkIdx++)
{
UEdGraphPin* OtherPin = LinkedToRef[LinkIdx];
// If we are linked to a pin that its owner doesn't know about, break that link
if (!OtherPin->GetOwningNode()->Pins.Contains(OtherPin))
{
Pin->LinkedTo.Remove(OtherPin);
}
}
}
// Store the old Input and Output pins
TArray<UEdGraphPin*> OldInputPins;
GetInputPins(OldInputPins);
UEdGraphPin* OldOutputPin = GetOutputPin();
// Move the existing pins to a saved array
TArray<UEdGraphPin*> OldPins(Pins);
Pins.Empty();
// Recreate the new pins
AllocateDefaultPins();
// Get new Input and Output pins
TArray<UEdGraphPin*> NewInputPins;
GetInputPins(NewInputPins);
UEdGraphPin* NewOutputPin = GetOutputPin();
for (int32 PinIndex = 0; PinIndex < OldInputPins.Num(); PinIndex++)
{
if (PinIndex < NewInputPins.Num())
{
NewInputPins[PinIndex]->CopyPersistentDataFromOldPin(*OldInputPins[PinIndex]);
}
}
NewOutputPin->CopyPersistentDataFromOldPin(*OldOutputPin);
OldInputPins.Empty();
OldOutputPin = NULL;
// Throw away the original pins
for (int32 OldPinIndex = 0; OldPinIndex < OldPins.Num(); ++OldPinIndex)
{
UEdGraphPin* OldPin = OldPins[OldPinIndex];
OldPin->Modify();
OldPin->BreakAllPinLinks();
UEdGraphNode::DestroyPin(OldPin);
}
OldPins.Empty();
}
void UK2Node::ReconstructNode()
{
Modify();
UBlueprint* Blueprint = GetBlueprint();
// Break any links to 'orphan' pins
for (int32 PinIndex = 0; PinIndex < Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Pins[PinIndex];
TArray<class UEdGraphPin*> LinkedToCopy = Pin->LinkedTo;
for (int32 LinkIdx = 0; LinkIdx < LinkedToCopy.Num(); LinkIdx++)
{
UEdGraphPin* OtherPin = LinkedToCopy[LinkIdx];
// If we are linked to a pin that its owner doesn't know about, break that link
if ((OtherPin == NULL) || !OtherPin->GetOwningNodeUnchecked() || !OtherPin->GetOwningNode()->Pins.Contains(OtherPin))
{
Pin->LinkedTo.Remove(OtherPin);
}
}
}
// Move the existing pins to a saved array
TArray<UEdGraphPin*> OldPins(Pins);
Pins.Empty();
// Recreate the new pins
ReallocatePinsDuringReconstruction(OldPins);
bool bDestroyOldPins = true;
if (Pins.Num() == 0)
{
//keep old pins on callfunction so that graph doesn't get broken up just because function is missing
if (IsA(UK2Node_CallFunction::StaticClass()) || IsA(UK2Node_MacroInstance::StaticClass()))
{
Pins = OldPins;
bDestroyOldPins = false;
}
}
else
{
RewireOldPinsToNewPins(OldPins, Pins);
}
if (bDestroyOldPins)
{
DestroyPinList(OldPins);
}
// Let subclasses do any additional work
PostReconstructNode();
GetGraph()->NotifyGraphChanged();
}
void UEdGraphSchema::TrySetDefaultValue(UEdGraphPin& Pin, const FString& NewDefaultValue) const
{
Pin.DefaultValue = NewDefaultValue;
#if WITH_EDITOR
UEdGraphNode* Node = Pin.GetOwningNode();
check(Node);
Node->PinDefaultValueChanged(&Pin);
#endif //#if WITH_EDITOR
}
void UEdGraphSchema::TrySetDefaultObject(UEdGraphPin& Pin, UObject* NewDefaultObject) const
{
Pin.DefaultObject = NewDefaultObject;
#if WITH_EDITOR
UEdGraphNode* Node = Pin.GetOwningNode();
check(Node);
Node->PinDefaultValueChanged(&Pin);
#endif //#if WITH_EDITOR
}
void UEdGraphSchema::TrySetDefaultText(UEdGraphPin& InPin, const FText& InNewDefaultText) const
{
InPin.DefaultTextValue = InNewDefaultText;
#if WITH_EDITOR
UEdGraphNode* Node = InPin.GetOwningNode();
check(Node);
Node->PinDefaultValueChanged(&InPin);
#endif //#if WITH_EDITOR
}
void FScriptExecutionTunnelExit::NavigateToExitSite(const uint32 TracePath) const
{
UEdGraphPin* Pin = ObservedPin.Get();
if (const FTunnelExitInstanceData* SearchResult = InstanceExitSiteInfo.Find(TracePath))
{
Pin = SearchResult->InstancePin.Get();
}
if (Pin)
{
FKismetEditorUtilities::BringKismetToFocusAttentionOnObject(Pin->GetOwningNode());
}
}
FReply FKismetVariableDragDropAction::DroppedOnPin(FVector2D ScreenPosition, FVector2D GraphPosition)
{
UEdGraphPin* TargetPin = GetHoveredPin();
if (TargetPin != NULL)
{
if (const UEdGraphSchema_K2* Schema = CastChecked<const UEdGraphSchema_K2>(TargetPin->GetSchema()))
{
UProperty* VariableProperty = GetVariableProperty();
if(CanVariableBeDropped(VariableProperty, *TargetPin->GetOwningNode()->GetGraph()))
{
const bool bIsRead = TargetPin->Direction == EGPD_Input;
const UBlueprint* Blueprint = FBlueprintEditorUtils::FindBlueprintForNode(TargetPin->GetOwningNode());
const bool bReadOnlyProperty = FBlueprintEditorUtils::IsPropertyReadOnlyInCurrentBlueprint(Blueprint, VariableProperty);
const bool bCanWriteIfNeeded = bIsRead || !bReadOnlyProperty;
FEdGraphPinType VariablePinType;
Schema->ConvertPropertyToPinType(VariableProperty, VariablePinType);
const bool bTypeMatch = Schema->ArePinTypesCompatible(VariablePinType, TargetPin->PinType);
if (bTypeMatch && bCanWriteIfNeeded)
{
FEdGraphSchemaAction_K2NewNode Action;
UK2Node_Variable* VarNode = bIsRead ? (UK2Node_Variable*)NewObject<UK2Node_VariableGet>() : (UK2Node_Variable*)NewObject<UK2Node_VariableSet>();
Action.NodeTemplate = VarNode;
UBlueprint* DropOnBlueprint = FBlueprintEditorUtils::FindBlueprintForGraph(TargetPin->GetOwningNode()->GetGraph());
UEdGraphSchema_K2::ConfigureVarNode(VarNode, VariableName, VariableSource.Get(), DropOnBlueprint);
Action.PerformAction(TargetPin->GetOwningNode()->GetGraph(), TargetPin, GraphPosition);
}
}
}
}
return FReply::Handled();
}
/** Find Pin in array that matches pin */
static class UEdGraphPin* FindOtherLink(TArray<class UEdGraphPin*>& Links2, int32 OriginalIndex, class UEdGraphPin* PinToFind)
{
//sometimes the order of the pins is different between revisions, although the pins themselves are unchanged, so we have to look at all of them
UEdGraphNode* Node1 = PinToFind->GetOwningNode();
for(auto It(Links2.CreateIterator());It;++It)
{
UEdGraphPin* Other = *It;
UEdGraphNode* Node2 = Other->GetOwningNode();
if(IsNodeMatch(Node1, Node2))
{
return Other;
}
}
return Links2[OriginalIndex];
}
const FSlateBrush* SGraphPin::GetPinStatusIcon() const
{
UEdGraphPin* WatchedPin = ((GraphPinObj->Direction == EGPD_Input) && (GraphPinObj->LinkedTo.Num() > 0)) ? GraphPinObj->LinkedTo[0] : GraphPinObj;
UBlueprint* Blueprint = FBlueprintEditorUtils::FindBlueprintForNodeChecked(WatchedPin->GetOwningNode());
if (FKismetDebugUtilities::IsPinBeingWatched(Blueprint, WatchedPin) )
{
return FEditorStyle::GetBrush( TEXT("Graph.WatchedPinIcon_Pinned") );
}
else
{
return NULL;
}
}
void UBehaviorTreeGraphNode_SimpleParallel::GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextOut) const
{
ensure(Pin.GetOwningNode() == this);
if (Pin.Direction == EGPD_Output)
{
if (Pin.PinType.PinCategory == UBehaviorTreeEditorTypes::PinCategory_SingleTask)
{
HoverTextOut = LOCTEXT("PinHoverParallelMain","Main task of parrallel node").ToString();
}
else
{
HoverTextOut = LOCTEXT("PinHoverParallelBackground","Nodes running in the background, while main task is active").ToString();
}
}
}
void UEdGraphSchema_BehaviorTreeDecorator::GetBreakLinkToSubMenuActions( class FMenuBuilder& MenuBuilder, UEdGraphPin* InGraphPin )
{
// Make sure we have a unique name for every entry in the list
TMap< FString, uint32 > LinkTitleCount;
// Add all the links we could break from
for(TArray<class UEdGraphPin*>::TConstIterator Links(InGraphPin->LinkedTo); Links; ++Links)
{
UEdGraphPin* Pin = *Links;
FString TitleString = Pin->GetOwningNode()->GetNodeTitle(ENodeTitleType::ListView).ToString();
FText Title = FText::FromString( TitleString );
if ( Pin->PinName != TEXT("") )
{
TitleString = FString::Printf(TEXT("%s (%s)"), *TitleString, *Pin->PinName);
// Add name of connection if possible
FFormatNamedArguments Args;
Args.Add( TEXT("NodeTitle"), Title );
Args.Add( TEXT("PinName"), Pin->GetDisplayName() );
Title = FText::Format( LOCTEXT("BreakDescPin", "{NodeTitle} ({PinName})"), Args );
}
uint32 &Count = LinkTitleCount.FindOrAdd( TitleString );
FText Description;
FFormatNamedArguments Args;
Args.Add( TEXT("NodeTitle"), Title );
Args.Add( TEXT("NumberOfNodes"), Count );
if ( Count == 0 )
{
Description = FText::Format( LOCTEXT("BreakDesc", "Break link to {NodeTitle}"), Args );
}
else
{
Description = FText::Format( LOCTEXT("BreakDescMulti", "Break link to {NodeTitle} ({NumberOfNodes})"), Args );
}
++Count;
MenuBuilder.AddMenuEntry( Description, Description, FSlateIcon(), FUIAction(
FExecuteAction::CreateUObject((USoundClassGraphSchema*const)this, &USoundClassGraphSchema::BreakSinglePinLink, const_cast< UEdGraphPin* >(InGraphPin), *Links) ) );
}
}
FReply FDragConnection::DroppedOnPin(FVector2D ScreenPosition, FVector2D GraphPosition)
{
TArray<UEdGraphPin*> ValidSourcePins;
ValidateGraphPinList(/*out*/ ValidSourcePins);
const FScopedTransaction Transaction( NSLOCTEXT("UnrealEd", "GraphEd_CreateConnection", "Create Pin Link") );
UEdGraphPin* PinB = GetHoveredPin();
bool bError = false;
TSet<UEdGraphNode*> NodeList;
for (UEdGraphPin* PinA : ValidSourcePins)
{
if ((PinA != NULL) && (PinB != NULL))
{
UEdGraph* MyGraphObj = PinA->GetOwningNode()->GetGraph();
if (MyGraphObj->GetSchema()->TryCreateConnection(PinA, PinB))
{
NodeList.Add(PinA->GetOwningNode());
NodeList.Add(PinB->GetOwningNode());
}
}
else
{
bError = true;
}
}
// Send all nodes that received a new pin connection a notification
for (auto It = NodeList.CreateConstIterator(); It; ++It)
{
UEdGraphNode* Node = (*It);
Node->NodeConnectionListChanged();
}
if (bError)
{
return FReply::Unhandled();
}
return FReply::Handled();
}
void UMaterialGraphSchema::BreakPinLinks(UEdGraphPin& TargetPin, bool bSendsNodeNotifcation) const
{
const FScopedTransaction Transaction( NSLOCTEXT("UnrealEd", "GraphEd_BreakPinLinks", "Break Pin Links") );
bool bHasLinksToBreak = false;
for (auto LinkIt = TargetPin.LinkedTo.CreateConstIterator(); LinkIt; ++LinkIt)
{
if (*LinkIt)
{
bHasLinksToBreak = true;
}
}
Super::BreakPinLinks(TargetPin, bSendsNodeNotifcation);
// if this would notify the node then we need to re-compile material
if (bSendsNodeNotifcation && bHasLinksToBreak)
{
FMaterialEditorUtilities::UpdateMaterialAfterGraphChange(TargetPin.GetOwningNode()->GetGraph());
}
}
void UBehaviorTreeGraph::ReplaceNodeConnections(UEdGraphNode* OldNode, UEdGraphNode* NewNode)
{
for (int32 Index = 0; Index < Nodes.Num(); ++Index)
{
UEdGraphNode* Node = Nodes[Index];
for (int32 PinIndex = 0; PinIndex < Node->Pins.Num(); PinIndex++)
{
UEdGraphPin* Pin = Node->Pins[PinIndex];
for (int32 LinkedIndex = 0; LinkedIndex < Pin->LinkedTo.Num(); LinkedIndex++)
{
UEdGraphPin* LinkedPin = Pin->LinkedTo[LinkedIndex];
const UEdGraphNode* LinkedNode = LinkedPin ? LinkedPin->GetOwningNode() : NULL;
if (LinkedNode == OldNode)
{
const int32 LinkedPinIndex = LinkedNode->Pins.IndexOfByKey(LinkedPin);
Pin->LinkedTo[LinkedIndex] = NewNode->Pins[LinkedPinIndex];
}
}
}
}
}
bool UAnimationGraphSchema::CreateAutomaticConversionNodeAndConnections(UEdGraphPin* PinA, UEdGraphPin* PinB) const
{
// Determine which pin is an input and which pin is an output
UEdGraphPin* InputPin = NULL;
UEdGraphPin* OutputPin = NULL;
if (!CategorizePinsByDirection(PinA, PinB, /*out*/ InputPin, /*out*/ OutputPin))
{
return false;
}
// Look for animation specific conversion operations
UK2Node* TemplateNode = NULL;
if (IsComponentSpacePosePin(OutputPin->PinType) && IsLocalSpacePosePin(InputPin->PinType))
{
TemplateNode = NewObject<UAnimGraphNode_ComponentToLocalSpace>();
}
else if (IsLocalSpacePosePin(OutputPin->PinType) && IsComponentSpacePosePin(InputPin->PinType))
{
TemplateNode = NewObject<UAnimGraphNode_LocalToComponentSpace>();
}
// Spawn the conversion node if it's specific to animation
if (TemplateNode != NULL)
{
UEdGraph* Graph = InputPin->GetOwningNode()->GetGraph();
FVector2D AverageLocation = CalculateAveragePositionBetweenNodes(InputPin, OutputPin);
UK2Node* ConversionNode = FEdGraphSchemaAction_K2NewNode::SpawnNodeFromTemplate<UK2Node>(Graph, TemplateNode, AverageLocation);
AutowireConversionNode(InputPin, OutputPin, ConversionNode);
return true;
}
else
{
// Give the regular conversions a shot
return Super::CreateAutomaticConversionNodeAndConnections(PinA, PinB);
}
}
void UNiagaraNodeInput::ReallocatePins()
{
const UEdGraphSchema_Niagara* Schema = GetDefault<UEdGraphSchema_Niagara>();
Modify();
// Break any links to 'orphan' pins
for (int32 PinIndex = 0; PinIndex < Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Pins[PinIndex];
TArray<class UEdGraphPin*>& LinkedToRef = Pin->LinkedTo;
for (int32 LinkIdx = 0; LinkIdx < LinkedToRef.Num(); LinkIdx++)
{
UEdGraphPin* OtherPin = LinkedToRef[LinkIdx];
// If we are linked to a pin that its owner doesn't know about, break that link
if (!OtherPin->GetOwningNode()->Pins.Contains(OtherPin))
{
Pin->LinkedTo.Remove(OtherPin);
}
}
}
// Store the old Input and Output pins
TArray<UEdGraphPin*> OldInputPins;
TArray<UEdGraphPin*> OldOutputPins;
GetInputPins(OldInputPins);
GetOutputPins(OldOutputPins);
// Move the existing pins to a saved array
TArray<UEdGraphPin*> OldPins(Pins);
Pins.Empty();
switch (Input.Type)
{
case ENiagaraDataType::Scalar:
{
CreatePin(EGPD_Output, Schema->PC_Float, TEXT(""), NULL, false, false, Input.Name.ToString());
}
break;
case ENiagaraDataType::Vector:
{
CreatePin(EGPD_Output, Schema->PC_Vector, TEXT(""), NULL, false, false, Input.Name.ToString());
}
break;
case ENiagaraDataType::Matrix:
{
CreatePin(EGPD_Output, Schema->PC_Matrix, TEXT(""), NULL, false, false, Input.Name.ToString());
}
break;
case ENiagaraDataType::Curve:
{
CreatePin(EGPD_Output, Schema->PC_Curve, TEXT(""), NULL, false, false, Input.Name.ToString());
}
break;
};
// Get new Input and Output pins
TArray<UEdGraphPin*> NewInputPins;
TArray<UEdGraphPin*> NewOutputPins;
GetInputPins(NewInputPins);
GetOutputPins(NewOutputPins);
for (int32 PinIndex = 0; PinIndex < OldInputPins.Num(); PinIndex++)
{
if (PinIndex < NewInputPins.Num())
{
NewInputPins[PinIndex]->CopyPersistentDataFromOldPin(*OldInputPins[PinIndex]);
}
}
for (int32 PinIndex = 0; PinIndex < OldOutputPins.Num(); PinIndex++)
{
if (PinIndex < NewOutputPins.Num())
{
NewOutputPins[PinIndex]->CopyPersistentDataFromOldPin(*OldOutputPins[PinIndex]);
}
}
OldInputPins.Empty();
OldOutputPins.Empty();
// Throw away the original pins
for (int32 OldPinIndex = 0; OldPinIndex < OldPins.Num(); ++OldPinIndex)
{
UEdGraphPin* OldPin = OldPins[OldPinIndex];
OldPin->Modify();
OldPin->BreakAllPinLinks();
#if 0
UEdGraphNode::ReturnPinToPool(OldPin);
#else
OldPin->Rename(NULL, GetTransientPackage(), REN_None);
OldPin->RemoveFromRoot();
OldPin->MarkPendingKill();
#endif
}
OldPins.Empty();
GetGraph()->NotifyGraphChanged();
}
void UNiagaraNodeOutput::ReallocatePins()
{
Modify();
// Break any links to 'orphan' pins
for (int32 PinIndex = 0; PinIndex < Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Pins[PinIndex];
TArray<class UEdGraphPin*>& LinkedToRef = Pin->LinkedTo;
for (int32 LinkIdx = 0; LinkIdx < LinkedToRef.Num(); LinkIdx++)
{
UEdGraphPin* OtherPin = LinkedToRef[LinkIdx];
// If we are linked to a pin that its owner doesn't know about, break that link
if (!OtherPin->GetOwningNode()->Pins.Contains(OtherPin))
{
Pin->LinkedTo.Remove(OtherPin);
}
}
}
// Store the old Input and Output pins
TArray<UEdGraphPin*> OldInputPins;
TArray<UEdGraphPin*> OldOutputPins;
GetInputPins(OldInputPins);
GetOutputPins(OldOutputPins);
// Move the existing pins to a saved array
TArray<UEdGraphPin*> OldPins(Pins);
Pins.Empty();
// Recreate the new pins
AllocateDefaultPins();
// Get new Input and Output pins
TArray<UEdGraphPin*> NewInputPins;
TArray<UEdGraphPin*> NewOutputPins;
GetInputPins(NewInputPins);
GetOutputPins(NewOutputPins);
for (int32 PinIndex = 0; PinIndex < OldInputPins.Num(); PinIndex++)
{
if (PinIndex < NewInputPins.Num())
{
NewInputPins[PinIndex]->CopyPersistentDataFromOldPin(*OldInputPins[PinIndex]);
}
}
for (int32 PinIndex = 0; PinIndex < OldOutputPins.Num(); PinIndex++)
{
if (PinIndex < NewOutputPins.Num())
{
NewOutputPins[PinIndex]->CopyPersistentDataFromOldPin(*OldOutputPins[PinIndex]);
}
}
OldInputPins.Empty();
OldOutputPins.Empty();
// Throw away the original pins
for (int32 OldPinIndex = 0; OldPinIndex < OldPins.Num(); ++OldPinIndex)
{
UEdGraphPin* OldPin = OldPins[OldPinIndex];
OldPin->Modify();
OldPin->BreakAllPinLinks();
#if 0
UEdGraphNode::ReturnPinToPool(OldPin);
#else
OldPin->Rename(NULL, GetTransientPackage(), REN_None);
OldPin->RemoveFromRoot();
OldPin->MarkPendingKill();
#endif
}
OldPins.Empty();
GetGraph()->NotifyGraphChanged();
}
FORCEINLINE bool operator()(const UEdGraphPin& A, const UEdGraphPin& B) const
{
return A.GetOwningNode()->NodePosX < B.GetOwningNode()->NodePosX;
}
void UK2Node::ReconstructNode()
{
Modify();
UBlueprint* Blueprint = GetBlueprint();
// Break any links to 'orphan' pins
for (int32 PinIndex = 0; PinIndex < Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Pins[PinIndex];
TArray<class UEdGraphPin*> LinkedToCopy = Pin->LinkedTo;
for (int32 LinkIdx = 0; LinkIdx < LinkedToCopy.Num(); LinkIdx++)
{
UEdGraphPin* OtherPin = LinkedToCopy[LinkIdx];
// If we are linked to a pin that its owner doesn't know about, break that link
if ((OtherPin == NULL) || !OtherPin->GetOwningNodeUnchecked() || !OtherPin->GetOwningNode()->Pins.Contains(OtherPin))
{
Pin->LinkedTo.Remove(OtherPin);
}
}
}
// Move the existing pins to a saved array
TArray<UEdGraphPin*> OldPins(Pins);
Pins.Empty();
// Recreate the new pins
ReallocatePinsDuringReconstruction(OldPins);
bool bDestroyOldPins = true;
if (Pins.Num() == 0)
{
//keep old pins on callfunction so that graph doesn't get broken up just because function is missing
if (IsA(UK2Node_CallFunction::StaticClass()) || IsA(UK2Node_MacroInstance::StaticClass()))
{
Pins = OldPins;
bDestroyOldPins = false;
}
}
else
{
// Rewire any connection to pins that are matched by name (O(N^2) right now)
//@TODO: Can do moderately smart things here if only one pin changes name by looking at it's relative position, etc...,
// rather than just failing to map it and breaking the links
for (int32 OldPinIndex = 0; OldPinIndex < OldPins.Num(); ++OldPinIndex)
{
UEdGraphPin* OldPin = OldPins[OldPinIndex];
for (int32 NewPinIndex = 0; NewPinIndex < Pins.Num(); ++NewPinIndex)
{
UEdGraphPin* NewPin = Pins[NewPinIndex];
const ERedirectType RedirectType = DoPinsMatchForReconstruction(NewPin, NewPinIndex, OldPin, OldPinIndex);
if (RedirectType != ERedirectType_None)
{
ReconstructSinglePin(NewPin, OldPin, RedirectType);
break;
}
}
}
}
if (bDestroyOldPins)
{
// Throw away the original pins
for (int32 OldPinIndex = 0; OldPinIndex < OldPins.Num(); ++OldPinIndex)
{
UEdGraphPin* OldPin = OldPins[OldPinIndex];
OldPin->Modify();
OldPin->BreakAllPinLinks();
// just in case this pin was set to watch (don't want to save PinWatches with dead pins)
Blueprint->PinWatches.Remove(OldPin);
#if 0
UEdGraphNode::ReturnPinToPool(OldPin);
#else
OldPin->Rename(NULL, GetTransientPackage(), (Blueprint->bIsRegeneratingOnLoad ? REN_ForceNoResetLoaders : REN_None));
OldPin->RemoveFromRoot();
OldPin->MarkPendingKill();
#endif
}
}
// Let subclasses do any additional work
PostReconstructNode();
GetGraph()->NotifyGraphChanged();
}
void FKismetVariableDragDropAction::HoverTargetChanged()
{
UProperty* VariableProperty = GetVariableProperty();
if (VariableProperty == nullptr)
{
return;
}
FString VariableString = VariableName.ToString();
// Icon/text to draw on tooltip
FSlateColor IconColor = FLinearColor::White;
const FSlateBrush* StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
FText Message = LOCTEXT("InvalidDropTarget", "Invalid drop target!");
UEdGraphPin* PinUnderCursor = GetHoveredPin();
bool bCanMakeSetter = true;
bool bBadSchema = false;
bool bBadGraph = false;
UEdGraph* HoveredGraph = GetHoveredGraph();
if (HoveredGraph)
{
if (Cast<const UEdGraphSchema_K2>(HoveredGraph->GetSchema()) == NULL)
{
bBadSchema = true;
}
else if(!CanVariableBeDropped(VariableProperty, *HoveredGraph))
{
bBadGraph = true;
}
UStruct* Outer = CastChecked<UStruct>(VariableProperty->GetOuter());
FNodeConstructionParams NewNodeParams;
NewNodeParams.VariableName = VariableName;
const UBlueprint* DropOnBlueprint = FBlueprintEditorUtils::FindBlueprintForGraph(HoveredGraph);
NewNodeParams.Graph = HoveredGraph;
NewNodeParams.VariableSource = Outer;
bCanMakeSetter = CanExecuteMakeSetter(NewNodeParams, VariableProperty);
}
UEdGraphNode* VarNodeUnderCursor = Cast<UK2Node_Variable>(GetHoveredNode());
if (bBadSchema)
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = LOCTEXT("CannotCreateInThisSchema", "Cannot access variables in this type of graph");
}
else if(bBadGraph)
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(VariableString));
Args.Add(TEXT("Scope"), FText::FromString(HoveredGraph->GetName()));
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
if(IsFromBlueprint(FBlueprintEditorUtils::FindBlueprintForGraph(HoveredGraph)) && VariableProperty->GetOuter()->IsA(UFunction::StaticClass()))
{
Message = FText::Format( LOCTEXT("IncorrectGraphForLocalVariable_Error", "Cannot place local variable '{VariableName}' in external scope '{Scope}'"), Args);
}
else
{
Message = FText::Format( LOCTEXT("IncorrectGraphForVariable_Error", "Cannot place variable '{VariableName}' in external scope '{Scope}'"), Args);
}
}
else if (PinUnderCursor != NULL)
{
FFormatNamedArguments Args;
Args.Add(TEXT("PinUnderCursor"), FText::FromString(PinUnderCursor->PinName));
Args.Add(TEXT("VariableName"), FText::FromString(VariableString));
if(CanVariableBeDropped(VariableProperty, *PinUnderCursor->GetOwningNode()->GetGraph()))
{
const UEdGraphSchema_K2* Schema = CastChecked<const UEdGraphSchema_K2>(PinUnderCursor->GetSchema());
const bool bIsRead = PinUnderCursor->Direction == EGPD_Input;
const UBlueprint* Blueprint = FBlueprintEditorUtils::FindBlueprintForNode(PinUnderCursor->GetOwningNode());
const bool bReadOnlyProperty = FBlueprintEditorUtils::IsPropertyReadOnlyInCurrentBlueprint(Blueprint, VariableProperty);
const bool bCanWriteIfNeeded = bIsRead || !bReadOnlyProperty;
FEdGraphPinType VariablePinType;
Schema->ConvertPropertyToPinType(VariableProperty, VariablePinType);
const bool bTypeMatch = Schema->ArePinTypesCompatible(VariablePinType, PinUnderCursor->PinType);
Args.Add(TEXT("PinUnderCursor"), FText::FromString(PinUnderCursor->PinName));
if (bTypeMatch && bCanWriteIfNeeded)
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK"));
if (bIsRead)
{
Message = FText::Format(LOCTEXT("MakeThisEqualThat_PinEqualVariableName", "Make {PinUnderCursor} = {VariableName}"), Args);
}
else
{
Message = FText::Format(LOCTEXT("MakeThisEqualThat_VariableNameEqualPin", "Make {VariableName} = {PinUnderCursor}"), Args);
}
}
else
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
if (!bCanWriteIfNeeded)
{
Message = FText::Format(LOCTEXT("ReadOnlyVar_Error", "Cannot write to read-only variable '{VariableName}'"), Args);
}
else
{
Message = FText::Format(LOCTEXT("NotCompatible_Error", "The type of '{VariableName}' is not compatible with {PinUnderCursor}"), Args);
}
}
}
else
{
Args.Add(TEXT("Scope"), FText::FromString(PinUnderCursor->GetOwningNode()->GetGraph()->GetName()));
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("IncorrectGraphForPin_Error", "Cannot place local variable '{VariableName}' in external scope '{Scope}'"), Args);
}
}
else if (VarNodeUnderCursor != NULL)
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(VariableString));
if(CanVariableBeDropped(VariableProperty, *VarNodeUnderCursor->GetGraph()))
{
const bool bIsRead = VarNodeUnderCursor->IsA(UK2Node_VariableGet::StaticClass());
const UBlueprint* Blueprint = FBlueprintEditorUtils::FindBlueprintForNode(VarNodeUnderCursor);
const bool bReadOnlyProperty = FBlueprintEditorUtils::IsPropertyReadOnlyInCurrentBlueprint(Blueprint, VariableProperty);
const bool bCanWriteIfNeeded = bIsRead || !bReadOnlyProperty;
if (bCanWriteIfNeeded)
{
Args.Add(TEXT("ReadOrWrite"), bIsRead ? LOCTEXT("Read", "read") : LOCTEXT("Write", "write"));
if(WillBreakLinks(VarNodeUnderCursor, VariableProperty))
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OKWarn"));
Message = FText::Format( LOCTEXT("ChangeNodeToWarnBreakLinks", "Change node to {ReadOrWrite} '{VariableName}', WARNING this will break links!"), Args);
}
else
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK"));
Message = FText::Format( LOCTEXT("ChangeNodeTo", "Change node to {ReadOrWrite} '{VariableName}'"), Args);
}
}
else
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("ReadOnlyVar_Error", "Cannot write to read-only variable '{VariableName}'"), Args);
}
}
else
{
Args.Add(TEXT("Scope"), FText::FromString(VarNodeUnderCursor->GetGraph()->GetName()));
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("IncorrectGraphForNodeReplace_Error", "Cannot replace node with local variable '{VariableName}' in external scope '{Scope}'"), Args);
}
}
else if (!HoveredCategoryName.IsEmpty())
{
// Find Blueprint that made this class and get category of variable
FText Category;
UBlueprint* Blueprint;
// Find the Blueprint for this property
if(Cast<UFunction>(VariableSource.Get()))
{
Blueprint = UBlueprint::GetBlueprintFromClass(Cast<UClass>(VariableSource->GetOuter()));
}
else
{
Blueprint = UBlueprint::GetBlueprintFromClass(Cast<UClass>(VariableSource.Get()));
}
if(Blueprint != NULL)
{
Category = FBlueprintEditorUtils::GetBlueprintVariableCategory(Blueprint, VariableProperty->GetFName(), GetLocalVariableScope() );
}
// See if class is native
UClass* OuterClass = Cast<UClass>(VariableProperty->GetOuter());
if(OuterClass || Cast<UFunction>(VariableProperty->GetOuter()))
{
const bool bIsNativeVar = (OuterClass && OuterClass->ClassGeneratedBy == NULL);
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(VariableString));
Args.Add(TEXT("HoveredCategoryName"), HoveredCategoryName);
if (bIsNativeVar)
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("ChangingCatagoryNotThisVar", "Cannot change category for variable '{VariableName}'"), Args );
}
else if (Category.EqualTo(HoveredCategoryName))
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("ChangingCatagoryAlreadyIn", "Variable '{VariableName}' is already in category '{HoveredCategoryName}'"), Args );
}
else
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK"));
Message = FText::Format( LOCTEXT("ChangingCatagoryOk", "Move variable '{VariableName}' to category '{HoveredCategoryName}'"), Args );
}
}
}
else if (HoveredAction.IsValid())
{
if(HoveredAction.Pin()->GetTypeId() == FEdGraphSchemaAction_K2Var::StaticGetTypeId())
{
FEdGraphSchemaAction_K2Var* VarAction = (FEdGraphSchemaAction_K2Var*)HoveredAction.Pin().Get();
FName TargetVarName = VarAction->GetVariableName();
// Needs to have a valid index to move it (this excludes variables added through other means, like timelines/components
int32 MoveVarIndex = INDEX_NONE;
int32 TargetVarIndex = INDEX_NONE;
UBlueprint* Blueprint = UBlueprint::GetBlueprintFromClass(Cast<UClass>(VariableSource.Get()));
if(Blueprint != NULL)
{
MoveVarIndex = FBlueprintEditorUtils::FindNewVariableIndex(Blueprint, VariableName);
TargetVarIndex = FBlueprintEditorUtils::FindNewVariableIndex(Blueprint, TargetVarName);
}
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(VariableString));
Args.Add(TEXT("TargetVarName"), FText::FromName(TargetVarName));
if(MoveVarIndex == INDEX_NONE)
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("MoveVarDiffClass", "Cannot reorder variable '{VariableName}'."), Args );
}
else if(TargetVarIndex == INDEX_NONE)
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("MoveVarOther", "Cannot reorder variable '{VariableName}' before '{TargetVarName}'."), Args );
}
else if(VariableName == TargetVarName)
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format( LOCTEXT("MoveVarYourself", "Cannot reorder variable '{VariableName}' before itself."), Args );
}
else
{
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK"));
Message = FText::Format( LOCTEXT("MoveVarOK", "Reorder variable '{VariableName}' before '{TargetVarName}'"), Args );
}
}
}
else if (bAltDrag && !bCanMakeSetter)
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(VariableString));
StatusSymbol = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
Message = FText::Format(LOCTEXT("CannotPlaceSetter", "Variable '{VariableName}' is readonly, you cannot set this variable."), Args);
}
// Draw variable icon
else
{
StatusSymbol = FBlueprintEditor::GetVarIconAndColor(VariableSource.Get(), VariableName, IconColor);
Message = FText::FromString(VariableString);
}
SetSimpleFeedbackMessage(StatusSymbol, IconColor, Message);
}
void UEdGraphNode::GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextOut) const
{
ensure(Pin.GetOwningNode() == this);
HoverTextOut = Pin.PinToolTip;
}
void UEnvironmentQueryGraph::UpdateVersion_NestedNodes()
{
for (int32 Idx = 0; Idx < Nodes.Num(); Idx++)
{
UEnvironmentQueryGraphNode_Option* OptionNode = Cast<UEnvironmentQueryGraphNode_Option>(Nodes[Idx]);
if (OptionNode)
{
UEnvironmentQueryGraphNode* Node = OptionNode;
while (Node)
{
UEnvironmentQueryGraphNode* NextNode = NULL;
for (int32 iPin = 0; iPin < Node->Pins.Num(); iPin++)
{
UEdGraphPin* TestPin = Node->Pins[iPin];
if (TestPin && TestPin->Direction == EGPD_Output)
{
for (int32 iLink = 0; iLink < TestPin->LinkedTo.Num(); iLink++)
{
UEdGraphPin* LinkedTo = TestPin->LinkedTo[iLink];
UEnvironmentQueryGraphNode_Test* LinkedTest = LinkedTo ? Cast<UEnvironmentQueryGraphNode_Test>(LinkedTo->GetOwningNode()) : NULL;
if (LinkedTest)
{
LinkedTest->ParentNode = OptionNode;
OptionNode->SubNodes.Add(LinkedTest);
NextNode = LinkedTest;
break;
}
}
break;
}
}
Node = NextNode;
}
}
}
for (int32 Idx = Nodes.Num() - 1; Idx >= 0; Idx--)
{
UEnvironmentQueryGraphNode_Test* TestNode = Cast<UEnvironmentQueryGraphNode_Test>(Nodes[Idx]);
if (TestNode)
{
TestNode->Pins.Empty();
Nodes.RemoveAt(Idx);
continue;
}
UEnvironmentQueryGraphNode_Option* OptionNode = Cast<UEnvironmentQueryGraphNode_Option>(Nodes[Idx]);
if (OptionNode && OptionNode->Pins.IsValidIndex(1))
{
OptionNode->Pins[1]->MarkPendingKill();
OptionNode->Pins.RemoveAt(1);
}
}
}
