void UK2Node_GetArrayItem::PropagatePinType(FEdGraphPinType& InType)
{
UClass const* CallingContext = NULL;
if (UBlueprint const* Blueprint = GetBlueprint())
{
CallingContext = Blueprint->GeneratedClass;
if (CallingContext == NULL)
{
CallingContext = Blueprint->ParentClass;
}
}
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* ArrayPin = Pins[0];
UEdGraphPin* ResultPin = Pins[2];
ArrayPin->PinType = InType;
ArrayPin->PinType.bIsArray = true;
ArrayPin->PinType.bIsReference = false;
ResultPin->PinType = InType;
ResultPin->PinType.bIsArray = false;
ResultPin->PinType.bIsReference = !(ResultPin->PinType.PinCategory == Schema->PC_Object || ResultPin->PinType.PinCategory == Schema->PC_Class || ResultPin->PinType.PinCategory == Schema->PC_Asset || ResultPin->PinType.PinCategory == Schema->PC_AssetClass || ResultPin->PinType.PinCategory == Schema->PC_Interface);
ResultPin->PinType.bIsConst = false;
// Verify that all previous connections to this pin are still valid with the new type
for (TArray<UEdGraphPin*>::TIterator ConnectionIt(ArrayPin->LinkedTo); ConnectionIt; ++ConnectionIt)
{
UEdGraphPin* ConnectedPin = *ConnectionIt;
if (!Schema->ArePinsCompatible(ArrayPin, ConnectedPin, CallingContext))
{
ArrayPin->BreakLinkTo(ConnectedPin);
}
}
// Verify that all previous connections to this pin are still valid with the new type
for (TArray<UEdGraphPin*>::TIterator ConnectionIt(ResultPin->LinkedTo); ConnectionIt; ++ConnectionIt)
{
UEdGraphPin* ConnectedPin = *ConnectionIt;
if (!Schema->ArePinsCompatible(ResultPin, ConnectedPin, CallingContext))
{
ResultPin->BreakLinkTo(ConnectedPin);
}
}
}
FReply FKismetVariableDragDropAction::DroppedOnNode(FVector2D ScreenPosition, FVector2D GraphPosition)
{
UK2Node_Variable* TargetNode = Cast<UK2Node_Variable>(GetHoveredNode());
if (TargetNode && (VariableName != TargetNode->GetVarName()))
{
const FScopedTransaction Transaction( LOCTEXT("ReplacePinVariable", "Replace Pin Variable") );
UProperty* VariableProperty = GetVariableProperty();
if(CanVariableBeDropped(VariableProperty, *TargetNode->GetGraph()))
{
const FString OldVarName = TargetNode->GetVarNameString();
const UEdGraphSchema_K2* Schema = Cast<const UEdGraphSchema_K2>(TargetNode->GetSchema());
TArray<class UEdGraphPin*> BadLinks;
GetLinksThatWillBreak(TargetNode,VariableProperty,BadLinks);
// Change the variable name and context
UBlueprint* DropOnBlueprint = FBlueprintEditorUtils::FindBlueprintForGraph(TargetNode->GetGraph());
UEdGraphPin* Pin = TargetNode->FindPin(OldVarName);
DropOnBlueprint->Modify();
TargetNode->Modify();
if (Pin != NULL)
{
Pin->Modify();
}
UEdGraphSchema_K2::ConfigureVarNode(TargetNode, VariableName, VariableSource.Get(), DropOnBlueprint);
if ((Pin == NULL) || (Pin->LinkedTo.Num() == BadLinks.Num()) || (Schema == NULL))
{
TargetNode->GetSchema()->ReconstructNode(*TargetNode);
}
else
{
FEdGraphPinType NewPinType;
Schema->ConvertPropertyToPinType(VariableProperty,NewPinType);
Pin->PinName = VariableName.ToString();
Pin->PinType = NewPinType;
//break bad links
for(TArray<class UEdGraphPin*>::TIterator OtherPinIt(BadLinks);OtherPinIt;)
{
Pin->BreakLinkTo(*OtherPinIt);
}
}
return FReply::Handled();
}
}
return FReply::Unhandled();
}
void UK2Node_MakeArray::PropagatePinType()
{
const UEdGraphPin* OutputPin = GetOutputPin();
if (OutputPin)
{
UClass const* CallingContext = NULL;
if (UBlueprint const* Blueprint = GetBlueprint())
{
CallingContext = Blueprint->GeneratedClass;
if (CallingContext == NULL)
{
CallingContext = Blueprint->ParentClass;
}
}
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
bool bWantRefresh = false;
// Propagate pin type info (except for array info!) to pins with dependent types
for (TArray<UEdGraphPin*>::TIterator it(Pins); it; ++it)
{
UEdGraphPin* CurrentPin = *it;
if (CurrentPin != OutputPin)
{
bWantRefresh = true;
CurrentPin->PinType.PinCategory = OutputPin->PinType.PinCategory;
CurrentPin->PinType.PinSubCategory = OutputPin->PinType.PinSubCategory;
CurrentPin->PinType.PinSubCategoryObject = OutputPin->PinType.PinSubCategoryObject;
// Verify that all previous connections to this pin are still valid with the new type
for (TArray<UEdGraphPin*>::TIterator ConnectionIt(CurrentPin->LinkedTo); ConnectionIt; ++ConnectionIt)
{
UEdGraphPin* ConnectedPin = *ConnectionIt;
if (!Schema->ArePinsCompatible(CurrentPin, ConnectedPin, CallingContext))
{
CurrentPin->BreakLinkTo(ConnectedPin);
}
}
}
}
// If we have a valid graph we should refresh it now to refelect any changes we made
if( (bWantRefresh == true ) && ( OutputPin->GetOwningNode() != NULL ) && ( OutputPin->GetOwningNode()->GetGraph() != NULL ) )
{
OutputPin->GetOwningNode()->GetGraph()->NotifyGraphChanged();
}
}
}
bool UK2Node_DynamicCast::ReconnectPureExecPins(TArray<UEdGraphPin*>& OldPins)
{
if (bIsPureCast)
{
// look for an old exec pin
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* PinExec = nullptr;
for (UEdGraphPin* Pin : OldPins)
{
if (Pin->PinName == K2Schema->PN_Execute)
{
PinExec = Pin;
break;
}
}
if (PinExec)
{
// look for old then pin
UEdGraphPin* PinThen = nullptr;
for (UEdGraphPin* Pin : OldPins)
{
if (Pin->PinName == K2Schema->PN_Then)
{
PinThen = Pin;
break;
}
}
if (PinThen)
{
// reconnect all incoming links to old exec pin to the far end of the old then pin.
if (PinThen->LinkedTo.Num() > 0)
{
UEdGraphPin* PinThenLinked = PinThen->LinkedTo[0];
while (PinExec->LinkedTo.Num() > 0)
{
UEdGraphPin* PinExecLinked = PinExec->LinkedTo[0];
PinExecLinked->BreakLinkTo(PinExec);
PinExecLinked->MakeLinkTo(PinThenLinked);
}
return true;
}
}
}
}
return false;
}
