void UK2Node_DelegateSet::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
if (SourceGraph != CompilerContext.ConsolidatedEventGraph)
{
CompilerContext.MessageLog.Error(*FString::Printf(*NSLOCTEXT("KismetCompiler", "InvalidNodeOutsideUbergraph_Error", "Unexpected node @@ found outside ubergraph.").ToString()), this);
}
else
{
UFunction* TargetFunction = GetDelegateSignature();
if(TargetFunction != NULL)
{
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
// First, create an event node matching the delegate signature
UK2Node_Event* DelegateEvent = CompilerContext.SpawnIntermediateEventNode<UK2Node_Event>(this, nullptr, SourceGraph);
DelegateEvent->EventReference.SetFromField<UFunction>(TargetFunction, false);
DelegateEvent->CustomFunctionName = GetDelegateTargetEntryPointName();
DelegateEvent->bInternalEvent = true;
DelegateEvent->AllocateDefaultPins();
// Move the pins over to the newly created event node
for( TArray<UEdGraphPin*>::TIterator PinIt(DelegateEvent->Pins); PinIt; ++PinIt )
{
UEdGraphPin* CurrentPin = *PinIt;
check(CurrentPin);
if( CurrentPin->Direction == EGPD_Output )
{
if( CurrentPin->PinType.PinCategory == Schema->PC_Exec )
{
// Hook up the exec pin specially, since it has a different name on the dynamic delegate node
UEdGraphPin* OldExecPin = FindPin(Schema->PN_DelegateEntry);
check(OldExecPin);
CompilerContext.MovePinLinksToIntermediate(*OldExecPin, *CurrentPin);
}
else if( CurrentPin->PinName != UK2Node_Event::DelegateOutputName )
{
// Hook up all other pins, EXCEPT the delegate output pin, which isn't needed in this case
UEdGraphPin* OldPin = FindPin(CurrentPin->PinName);
if( !OldPin )
{
// If we couldn't find the old pin, the function signature is out of date. Tell them to reconstruct
CompilerContext.MessageLog.Error(*FString::Printf(*NSLOCTEXT("KismetCompiler", "EventNodeOutOfDate_Error", "Event node @@ is out-of-date. Please refresh it.").ToString()), this);
return;
}
CompilerContext.MovePinLinksToIntermediate(*OldPin, *CurrentPin);
}
}
}
}
else
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("DelegateSigNotFound_Error", "Set Delegate node @@ unable to find function.").ToString()), this);
}
}
}
void UK2Node_DelegateSet::ValidateNodeDuringCompilation(class FCompilerResultsLog& MessageLog) const
{
Super::ValidateNodeDuringCompilation(MessageLog);
// If we are overriding a function, but we can;t find the function we are overriding, that is a compile error
if(GetDelegateSignature() == NULL)
{
MessageLog.Error(*FString::Printf(*NSLOCTEXT("KismetCompiler", "MissingDelegateSig_Error", "Unable to find delegate '%s' for @@").ToString(), *DelegatePropertyName.ToString()), this);
}
}
void UK2Node_DelegateSet::AllocateDefaultPins()
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
// Cache off the delegate signature, which will update the DelegatePropertyName as well, if it's been redirected
UFunction* DelegateSignature = GetDelegateSignature();
CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Execute);
CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), DelegatePropertyClass, false, false, DelegatePropertyName.ToString());
CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);
CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_DelegateEntry);
CreatePinsForFunctionEntryExit(DelegateSignature, true);
Super::AllocateDefaultPins();
}
FText UK2Node_DelegateSet::GetTooltipText() const
{
if (CachedTooltip.IsOutOfDate(this))
{
// FText::Format() is slow, so we cache this to save on performance
CachedTooltip.SetCachedText(FText::Format(NSLOCTEXT("K2Node", "CreateEventForDelegate", "Create an event tied to the delegate {0}"), FText::FromName(DelegatePropertyName)), this);
if (UFunction* Function = GetDelegateSignature())
{
const FText SignatureTooltip = Function->GetToolTipText();
if (!SignatureTooltip.IsEmpty())
{
CachedTooltip.SetCachedText(FText::Format(LOCTEXT("DelegateSet_SubtitledTooltip", "{0}\n{1}"), (FText&)CachedTooltip, SignatureTooltip), this);
}
}
}
return CachedTooltip;
}
void UK2Node_CallDelegate::AllocateDefaultPins()
{
Super::AllocateDefaultPins();
CreatePinsForFunctionInputs(GetDelegateSignature());
}
void UK2Node_RemoveDelegate::AllocateDefaultPins()
{
Super::AllocateDefaultPins();
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
if(UEdGraphPin* DelegatePin = CreatePin(EGPD_Input, K2Schema->PC_Delegate, TEXT(""), GetDelegateSignature(), false, false, FK2Node_BaseMCDelegateHelper::DelegatePinName))
{
DelegatePin->PinFriendlyName = *NSLOCTEXT("K2Node", "PinFriendlyDelegatetName", "Event").ToString();
}
}
