View difference between Paste ID: h4dmuHYf and qkWhr31q

 #include "SagaEditor.h"
 #include "UObject/UnrealType.h"
 #include "EdGraph/EdGraphPin.h"
 #include "Kismet/KismetSystemLibrary.h"
 #include "EdGraphSchema_K2.h"
 #include "K2Node_CallFunction.h"
 #include "K2Node_AssignmentStatement.h"
 #include "K2Node_CustomEvent.h"
 #include "K2Node_TemporaryVariable.h"
 #include "KismetCompiler.h"
 #include "BlueprintNodeSpawner.h"
 #include "BlueprintActionDatabaseRegistrar.h"
 #include "K2Node_Await.h"
 #include "Network/WarholdNetworkClasses.h"
 #include "K2Node_GetDataTableRow.h"
 #include "Network/UE4App.h"
 #include "BlueprintEditorUtils.h"
 #include "SGraphNode.h"
 #include "ContentBrowserModule.h"
 #include "Private/SAssetDialog.h"
 #include "GraphEditorSettings.h"
 
 #define LOCTEXT_NAMESPACE "K2Node_WN"
 
 void UK2Node_WN_Await::AllocateDefaultPins()
 {
 	const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());
 
 	CachedFunctionName = TEXT("...");
 
 	if (K2Schema)
 	{
 		CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), nullptr, false, false, K2Schema->PN_Execute);
 		UEdGraphPin* OutputExecPin = CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), nullptr, false, false, K2Schema->PN_Then);
 		if (OutputExecPin)
 		{
 			OutputExecPin->PinFriendlyName = FText::FromString(K2Schema->PN_Completed);
 		}
 
 		CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), UMailbox::StaticClass(), false, false, TEXT("Target"), false, INDEX_NONE, false, false);
 	}
 }
 
 void UK2Node_WN_Await::ReallocatePinsDuringReconstruction(TArray<UEdGraphPin*>& OldPins)
 {
 	AllocateDefaultPins();
 
 	ConstructMethodPinByMailbox(&OldPins);
 	MailboxPinChanged(&OldPins);
 
 	RestoreSplitPins(OldPins);
 }
 
 void UK2Node_WN_Await::PinConnectionListChanged(UEdGraphPin* Pin)
 {
 	Super::PinConnectionListChanged(Pin);
 
 	if (Pin->PinName == TEXT("Target"))
 	{
 		MailboxPinChanged();
 
 		// Refresh the UI for the graph so the pin changes show up
 		GetGraph()->NotifyGraphChanged();
 
 		// Mark dirty
 		FBlueprintEditorUtils::MarkBlueprintAsModified(GetBlueprint());
 	}
 }
 
 
 UEdGraphPin* UK2Node_WN_Await::GetPinSpecified(FString PinName, TArray<UEdGraphPin*>* OldPins)
 {
 	if (OldPins != nullptr)
 		for (auto& pin : *OldPins)
 			if (pin->PinName == PinName)
 				return pin;
 	return FindPin(PinName);
 }
 
 UClass* UK2Node_WN_Await::GetMailboxClass(TArray<UEdGraphPin*>* OldPins)
 {
 	UEdGraphPin* target_pin = GetPinSpecified("Target", OldPins);
 
 	UClass* MailboxClass = nullptr;
 
 	if (target_pin && target_pin->DefaultObject && target_pin->LinkedTo.Num() == 0)
 	{
 		MailboxClass = Cast<UClass>(target_pin->DefaultObject);
 	}
 	else if (target_pin && target_pin->LinkedTo.Num())
 	{
 		UEdGraphPin* ClassSource = target_pin->LinkedTo[0];
 		MailboxClass = ClassSource ? Cast<UClass>(ClassSource->PinType.PinSubCategoryObject.Get()) : nullptr;
 	}
 
 	return MailboxClass;
 }
 
 UEdGraphPin* UK2Node_WN_Await::ConstructMethodPinByMailbox(TArray<UEdGraphPin*>* OldPins, bool bRemovePrevious)
 {
 	CachedMailboxName = TEXT("");
 
 	const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());
 
 	UEdGraphPin* method_pin = nullptr;
 
 	if (K2Schema)
 	{
 		UClass* MailboxClass = GetMailboxClass(OldPins);
 
 		if (!MailboxClass)
 			CachedFunctionName = TEXT("...");
 
 		MailboxFunctionNames.Empty();
 		if (MailboxClass)
 		{
 
 			CachedMailboxName = MailboxClass->GetName();
 			for (auto func : TFieldRange<UFunction>(MailboxClass))
 			{
 				if (func->FunctionFlags & FUNC_BlueprintCallable)
 					if (auto ret_property = Cast<UObjectPropertyBase>(func->GetReturnProperty()))
 					{
 						if (ret_property->PropertyClass && ret_property->PropertyClass->IsChildOf<UFuture>())
 						{
 							MailboxFunctionNames.Add(*func->GetName());
 						}
 					}
 			}
 		}
 
 		method_pin = GetPinSpecified(TEXT("Method"), OldPins);
 
 		if (bRemovePrevious && method_pin && OldPins == nullptr)
 			RemovePin(method_pin);
 
 		if (MailboxClass && MailboxClass != UMailbox::StaticClass() && method_pin == nullptr)
 			method_pin = CreatePin(EGPD_Input, K2Schema->PC_Name, TEXT(""), nullptr, false, false, TEXT("Method"), false, INDEX_NONE, false, false);
 
 		if (method_pin)
 			method_pin->bHidden = false;
 	}
 
 	return method_pin;
 }
 
 void UK2Node_WN_Await::MailboxPinChanged(TArray<UEdGraphPin*>* OldPins)
 {
 
 	const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());
 
 	if (K2Schema)
 	{
 		UClass* MailboxClass = GetMailboxClass(OldPins);
 
 		UFunction* func = nullptr;
 
 		UEdGraphPin* method_pin = ConstructMethodPinByMailbox(OldPins, MailboxClass != CurrentMailboxClass || MailboxClass == nullptr);
 
 		if (MailboxClass)
 			func = GetMailboxFunction(MailboxClass, *method_pin->DefaultValue);
 
 
 		if (func != CurrentFunction || MailboxClass != CurrentMailboxClass || func == nullptr || MailboxClass == nullptr)
 		{
 			// Clears all previous pins
 			for (auto pin : CachedPins)
 				RemovePin(pin);
 			CachedPins.Empty();
 
 			CurrentFunction = func;
 			CurrentMailboxClass = MailboxClass;
 		} else
 		{
 			return;
 		}
 
 		CachedMailboxName = TEXT("");
 
 		if (MailboxClass)
 		{
 			CachedMailboxName = MailboxClass->GetName();
 
 			method_pin->bHidden = false;
 
 			if (func)
 			{
 				CachedFunctionName = method_pin->DefaultValue;
 				const UObject* const ClassDefaultObject = MailboxClass->GetDefaultObject(false);
 
 				UObjectPropertyBase* ReturnProperty = Cast<UObjectPropertyBase>(func->GetReturnProperty());
 
 				const TArray<UEdGraphPin*> in_pins = GeneratePinsForAsyncFunction(func, EGPD_Input);
 				CachedPins.Append(in_pins);
 
 				if (ReturnProperty)
 				{
 					UFunction* exec_func_return = ReturnProperty->PropertyClass->FindFunctionByName(TEXT("Execute"));
 					const TArray<UEdGraphPin*> out_pins = GeneratePinsForAsyncFunction(exec_func_return, EGPD_Output);
 					CachedPins.Append(out_pins);
 				}
 
 			}
 			else
 			{
 
 				CachedFunctionName = TEXT("...");
 			}
 		}
 	}
 }
 
 UFunction* UK2Node_WN_Await::GetMailboxFunction(UClass* MailboxClass, FName FunctionName)
 {
 	if (MailboxClass)
 		for (auto func : TFieldRange<UFunction>(MailboxClass))
 			if (func->FunctionFlags & FUNC_BlueprintCallable)
 				if (auto ret_property = Cast<UObjectPropertyBase>(func->GetReturnProperty()))
 					if (ret_property->PropertyClass && ret_property->PropertyClass->IsChildOf<UFuture>())
 						if (func->GetName() == FunctionName.ToString())
 							return func;
 	return nullptr;
 }
 
 TArray<UEdGraphPin*> UK2Node_WN_Await::GeneratePinsForAsyncFunction(UFunction* func, EEdGraphPinDirection direction)
 {
 	TArray<UEdGraphPin*> OutPins;
 	const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());
 	if (K2Schema && func)
 	{
 		UProperty* ReturnProperty = func->GetReturnProperty();
 		for (TFieldIterator<UProperty> PropertyIt(func, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
 		{
 			UProperty* Property = *PropertyIt;
 			if (*PropertyIt != ReturnProperty)
 				if (FBlueprintEditorUtils::PropertyStillExists(Property))
 					if (UEdGraphPin* Pin = CreatePin(direction, FString(), FString(), nullptr, Property->GetName()))
 					{
 						K2Schema->ConvertPropertyToPinType(Property, /*out*/ Pin->PinType);
 						OutPins.Add(Pin);
 					}
 		}
 	}
 	return OutPins;
 }
 
 void UK2Node_WN_Await::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
 {
 	Super::ExpandNode(CompilerContext, SourceGraph);
 
 	// TODO: Currently turned off due to reorganization of node from generated to customizable!
 
 	//const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
 	//check(Schema);
 	//bool bIsErrorFree = true;
 	//const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());
 	//// Create intermediate function call
 	//auto CallIntermediateFunctionNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
 	//CallIntermediateFunctionNode->FunctionReference.SetExternalMember(NativeFunctionName(), GetTargetClass());
 	//CallIntermediateFunctionNode->AllocateDefaultPins();
 	//
 	//TArray<FString> retvals;
     //TMap<FString, UObject*> retclasses;
 	//TMap<FString, bool> ret_bisarrays;
 	//
     //
 	//retvals.Add(TEXT("RetVal1"));
 	//retclasses.Add(TEXT("RetVal1"), USessionBaseMailbox::StaticClass());
 	//ret_bisarrays.Add(TEXT("RetVal1"), false);
 	//
 	//retvals.Add(TEXT("RetVal2"));
 	//retclasses.Add(TEXT("RetVal2"), FindObject<UEnum>(ANY_PACKAGE, TEXT("ELoginResult"), true));
 	//ret_bisarrays.Add(TEXT("RetVal2"), false);
 	//
 	//retvals.Add(TEXT("RetVal3"));
 	//retclasses.Add(TEXT("RetVal3"), nullptr);
 	//ret_bisarrays.Add(TEXT("RetVal3"), false);
 	//
 	//
 	//
 	//TArray<FString> connectors;
 	//
 	//connectors.Add(TEXT("username"));
 	//connectors.Add(TEXT("password"));
 	//
 	//
 	//
 	//// connect to input exe
 	//{
 	//	auto InputExePin = GetExecPin();
 	//	auto CallFunctionInputExePin = CallIntermediateFunctionNode->GetExecPin();
 	//	bIsErrorFree &= InputExePin && CallFunctionInputExePin && CompilerContext.MovePinLinksToIntermediate(*InputExePin, *CallFunctionInputExePin).CanSafeConnect();
 	//}
 	//
 	//TMap<FString, UK2Node_AssignmentStatement*> assignment_nodes_by_name;
 	//TArray<UK2Node_AssignmentStatement*>  assignment_nodes;
 	///// RetVals assignment section
 	//
 	//for (auto& retval_name : retvals)
 	//{
 	//	// Create Local Variable (for RetVal1)
 	//	auto PinCategory = FindPin(retval_name)->PinType.PinCategory;
 	//	// TODO: Old: // UK2Node_TemporaryVariable* TempVarOutput = CompilerContext.SpawnInternalVariable(this, PinCategory, FString(""), retclasses[retval_name], ret_bisarrays[retval_name]);
     //    UK2Node_TemporaryVariable* TempVarOutput = CompilerContext.SpawnInternalVariable(this, PinCategory, FString(""), retclasses[retval_name], FEdGraphPinType::ToPinContainerType(ret_bisarrays[retval_name], false, false));
 	//
 	//	// Create assign node (for RetVal1)
 	//	UK2Node_AssignmentStatement* AssignNode = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
 	//	assignment_nodes_by_name.Add(retval_name, AssignNode);
 	//	assignment_nodes.Add(AssignNode);
 	//
 	//	AssignNode->AllocateDefaultPins();
 	//
 	//
 	//	auto RetVal_VariablePin = TempVarOutput->GetVariablePin();
 	//
 	//	// connect local variable (for RetVal1) to assign node
 	//	auto AssignLHSPPin = AssignNode->GetVariablePin();
 	//	bIsErrorFree &= AssignLHSPPin && RetVal_VariablePin && Schema->TryCreateConnection(AssignLHSPPin, RetVal_VariablePin);
 	//
 	//	// connect local variable (for RetVal1) to output
 	//	auto OutputObjectPinPin = FindPin(retval_name);
 	//	bIsErrorFree &= RetVal_VariablePin && OutputObjectPinPin && CompilerContext.MovePinLinksToIntermediate(*OutputObjectPinPin, *RetVal_VariablePin).CanSafeConnect();
 	//}
 	//
 	//auto SchemaThen = FindPin(Schema->PN_Then);
 	//auto FirstPin = CallIntermediateFunctionNode->FindPin(Schema->PN_Then);
 	//auto LastPin = SchemaThen;
 	//
 	//for (int32 i = 0; i < assignment_nodes.Num(); i++)
 	//{
 	//	auto AssignNode = assignment_nodes[i];
 	//
 	//	UEdGraphPin* PrevPin = (i == 0)								? FirstPin : assignment_nodes[i - 1]->GetThenPin();
 	//	UEdGraphPin* NextPin = (i == assignment_nodes.Num() - 1)	? LastPin  : assignment_nodes[i + 1]->GetThenPin();
 	//
 	//	// connect assign (for RetVal1) exec input to function output
 	//	auto AssignInputExePin = AssignNode->GetExecPin();
 	//	bIsErrorFree &= AssignInputExePin && PrevPin && Schema->TryCreateConnection(AssignInputExePin, PrevPin);
 	//
 	//	// auto AssignOutputExePin = AssignNode->GetThenPin();
 	//	// bIsErrorFree &= NextPin && AssignOutputExePin && Schema->TryCreateConnection(NextPin, AssignOutputExePin);
 	//	if (i == assignment_nodes.Num() - 1)
 	//	{
 	//		auto AssignInputThenPin = AssignNode->GetThenPin();
 	//		bIsErrorFree &= AssignInputThenPin && LastPin && CompilerContext.MovePinLinksToIntermediate(*LastPin, *AssignInputThenPin).CanSafeConnect();
 	//	}
 	//
 	//}
 	//
 	//
 	//
 	//
 	///// END OF assignment sections
 	//
 	//
 	//// connect to Target
 	//auto CallIntermediateFunctionNodePin = CallIntermediateFunctionNode->FindPin(TEXT("Target"));
 	//{
 	//	auto TargetPin = FindPin(TEXT("Target"));
 	//	ensure(CallIntermediateFunctionNodePin);
 	//	bIsErrorFree &= TargetPin && CallIntermediateFunctionNodePin && CompilerContext.MovePinLinksToIntermediate(*TargetPin, *CallIntermediateFunctionNodePin).CanSafeConnect();
 	//}
 	//
 	//// Iterate over all named parameters
 	//for (auto& connector : connectors)
 	//{
 	//	auto IntermediatePin = CallIntermediateFunctionNode->FindPin(connector);
 	//	auto Pin = FindPin(connector);
 	//	ensure(IntermediatePin);
 	//	bIsErrorFree &= Pin && IntermediatePin && CompilerContext.MovePinLinksToIntermediate(*Pin, *IntermediatePin).CanSafeConnect();
 	//}
 	//
 	//// Create OnLoadEvent
 	//const FString DelegateOnLoadedParamName(TEXT("OnDone"));
 	//auto OnDoneEventNode = CompilerContext.SpawnIntermediateEventNode<UK2Node_CustomEvent>(this, CallIntermediateFunctionNodePin, SourceGraph);
 	//OnDoneEventNode->CustomFunctionName = *FString::Printf(TEXT("OnDone_%s"), *CompilerContext.GetGuid(this));
 	//OnDoneEventNode->AllocateDefaultPins();
 	//{
 	//	UFunction* LoadAssetFunction = CallIntermediateFunctionNode->GetTargetFunction();
 	//	UDelegateProperty* OnLoadDelegateProperty = LoadAssetFunction ? FindField<UDelegateProperty>(LoadAssetFunction, *DelegateOnLoadedParamName) : nullptr;
 	//	UFunction* OnLoadedSignature = OnLoadDelegateProperty ? OnLoadDelegateProperty->SignatureFunction : nullptr;
 	//	ensure(OnLoadedSignature);
 	//	for (TFieldIterator<UProperty> PropIt(OnLoadedSignature); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
 	//	{
 	//		const UProperty* Param = *PropIt;
 	//		if (!Param->HasAnyPropertyFlags(CPF_OutParm) || Param->HasAnyPropertyFlags(CPF_ReferenceParm))
 	//		{
 	//			FEdGraphPinType PinType;
 	//			bIsErrorFree &= Schema->ConvertPropertyToPinType(Param, /*out*/ PinType);
 	//			bIsErrorFree &= (NULL != OnDoneEventNode->CreateUserDefinedPin(Param->GetName(), PinType, EGPD_Output));
 	//		}
 	//	}
 	//}
 	//
 	//// connect delegate
 	//{
 	//	auto CallFunctionDelegatePin = CallIntermediateFunctionNode->FindPin(DelegateOnLoadedParamName);
 	//	ensure(CallFunctionDelegatePin);
 	//	auto EventDelegatePin = OnDoneEventNode->FindPin(UK2Node_CustomEvent::DelegateOutputName);
 	//	bIsErrorFree &= CallFunctionDelegatePin && EventDelegatePin && Schema->TryCreateConnection(CallFunctionDelegatePin, EventDelegatePin);
 	//}
 	//
 	//// connect loaded object from event to assign
 	//for (auto& pair : assignment_nodes_by_name)
 	//{
 	//	auto RetValEventPin = OnDoneEventNode->FindPin(pair.Key);
 	//	ensure(RetValEventPin);
 	//	auto AssignRHSPPin = pair.Value->GetValuePin();
 	//	bIsErrorFree &= AssignRHSPPin && RetValEventPin && Schema->TryCreateConnection(RetValEventPin, AssignRHSPPin);
 	//}
 	//
 	//if (!bIsErrorFree)
 	//{
 	//	CompilerContext.MessageLog.Error(*LOCTEXT("InternalConnectionError", "K2Node_WN_K2Node_BaseApp_login_LatentFunction: Internal connection error. @@").ToString(), this);
 	//}
 	//
 	BreakAllNodeLinks();
 }
 
 FText UK2Node_WN_Await::GetTooltipText() const
 {
 	return FText::Format(LOCTEXT("Await::GetTooltipText", "await {0}:{1}"), FText::FromString(CachedMailboxName), FText::FromString(CachedFunctionName));
 }
 
 void UK2Node_WN_Await::PinDefaultValueChanged(UEdGraphPin* Pin)
 {
 	if (Pin->PinName == TEXT("Method"))
 	{
 		MailboxPinChanged();
 
 		// Refresh the UI for the graph so the pin changes show up
 		GetGraph()->NotifyGraphChanged();
 
 		// Mark dirty
 		FBlueprintEditorUtils::MarkBlueprintAsModified(GetBlueprint());
 	}
 }
 
 FText UK2Node_WN_Await::GetNodeTitle(ENodeTitleType::Type TitleType) const
 {
 	return FText::Format(LOCTEXT("Await::GetNodeTitle", "await {0}"), FText::FromString(CachedFunctionName));
 }
 
 bool UK2Node_WN_Await::IsCompatibleWithGraph(const UEdGraph* TargetGraph) const
 {
 	bool bIsCompatible = false;
 	// Can only place events in ubergraphs and macros (other code will help prevent macros with latents from ending up in functions), and basicasync task creates an event node:
 	EGraphType GraphType = TargetGraph->GetSchema()->GetGraphType(TargetGraph);
 	if (GraphType == EGraphType::GT_Ubergraph || GraphType == EGraphType::GT_Macro)
 	{
 		bIsCompatible = true;
 	}
 	return bIsCompatible && Super::IsCompatibleWithGraph(TargetGraph);
 }
 
 FLinearColor UK2Node_WN_Await::GetNodeTitleColor() const
 {
 	return FLinearColor(1.f, 0.3, 0.3, 1.f);
 }
 
 FName UK2Node_WN_Await::GetCornerIcon() const
 {
 	return TEXT("Graph.Latent.LatentIcon");
 }
 
 void UK2Node_WN_Await::GetMenuActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
 {
 	// actions get registered under specific object-keys; the idea is that
 	// actions might have to be updated (or deleted) if their object-key is
 	// mutated (or removed)... here we use the node's class (so if the node
 	// type disappears, then the action should go with it)
 	UClass* ActionKey = GetClass();
 	// to keep from needlessly instantiating a UBlueprintNodeSpawner, first
 	// check to make sure that the registrar is looking for actions of this type
 	// (could be regenerating actions for a specific asset, and therefore the
 	// registrar would only accept actions corresponding to that asset)
 	if (ActionRegistrar.IsOpenForRegistration(ActionKey))
 	{
 		UBlueprintNodeSpawner* NodeSpawner = UBlueprintNodeSpawner::Create(GetClass());
 		check(NodeSpawner != nullptr);
 
 		ActionRegistrar.AddBlueprintAction(ActionKey, NodeSpawner);
 	}
 }
 
 FText UK2Node_WN_Await::GetMenuCategory() const
 {
 	return FText(LOCTEXT("Await", "Utilities"));
 }
 
 TSharedPtr<SGraphNode> UK2Node_WN_Await::CreateVisualWidget()
 {
 
 	return SNew(SK2Node_MethodsDropdown, this);
 }
 
 
 
 
 const UEdGraphSchema_K2* UK2Node_WN_Await::GetK2Schema()
 {
 	return CastChecked<UEdGraphSchema_K2>(GetSchema());
 }
 
 /// SK2Node_MethodsDropdown
 
 SK2Node_MethodsDropdown::FArguments::FArguments()
 {
 
 }
 
 
 void SK2Node_MethodsDropdown::Construct(const FArguments& InArgs, UK2Node_WN_Await* InNode)
 {
 	GraphNode = InNode;
 	Names = InNode->MailboxFunctionNames;
 	CurrentIcon = FSlateIcon();
 	UpdateGraphNode();
 }
 
 void SK2Node_MethodsDropdown::CreateStandardPinWidget(UEdGraphPin* Pin)
 {
 	if (Pin->PinName == "Method")
 	{
 		CreateDetailsPickers();
 	}
 	else
 	{
 		SGraphNode::CreateStandardPinWidget(Pin);
 	}
 }
 
 TSharedRef<SWidget> SK2Node_MethodsDropdown::GetPickerMenu()
 {
 	// Close self only to enable use inside context menus
 	FMenuBuilder MenuBuilder(true, nullptr, nullptr, true);
 
 
 	FSlateIcon Icon;
 
 	for (auto name : Names)
 	{
 		MenuBuilder.AddMenuEntry(
 			FText::FromName(name),
 			FText(),
 			Icon,
 			FUIAction(
 				FExecuteAction::CreateRaw(this, &SK2Node_MethodsDropdown::SetMethodName, name)
 			)
 		);
 	}
 
 
 	return MenuBuilder.MakeWidget();
 }
 
 void SK2Node_MethodsDropdown::OnAssetSelectedFromPicker(const FAssetData& AssetData)
 {
 	UpdateGraphNode();
 }
 
 FText SK2Node_MethodsDropdown::GetAssetName() const
 {
 	return FText();
 }
 
 void SK2Node_MethodsDropdown::CreateDetailsPickers()
 {
 	LeftNodeBox->AddSlot()
 	           .AutoHeight()
 	           .HAlign(HAlign_Left)
 	           .VAlign(VAlign_Center)
 	           .Padding(Settings->GetInputPinPadding())
 	[
 		SNew(SBox)
 		.MaxDesiredWidth(200.0f)
 		.Padding(FMargin(2, 0))
 		[
 			SNew(SComboButton)
 			.ButtonStyle(FEditorStyle::Get(), "PropertyEditor.AssetComboStyle")
 			// .ToolTipText(this, &SGraphNodeGetSequenceBinding::GetToolTipText)
 			.ForegroundColor(this, &SK2Node_MethodsDropdown::OnGetComboForeground)
 			.ButtonColorAndOpacity(this, &SK2Node_MethodsDropdown::OnGetWidgetBackground)
 			.ContentPadding(FMargin(2, 2, 2, 1))
 			.MenuPlacement(MenuPlacement_BelowAnchor)
 			.ButtonContent()
 			[
 				///
 				GetCurrentItemWidget(
 					SNew(STextBlock)
 					.TextStyle(FEditorStyle::Get(), "PropertyEditor.AssetClass")
 					.Font(FEditorStyle::GetFontStyle("PropertyWindow.NormalFont"))
 				)
 				///
 			]
 			.OnGetMenuContent(this, &SK2Node_MethodsDropdown::GetPickerMenu)
 		]
 	];
 }
 
 TSharedRef<SWidget> SK2Node_MethodsDropdown::GetCurrentItemWidget(TSharedRef<STextBlock> TextContent)
 {
 	TextContent->SetText(TAttribute<FText>::Create(TAttribute<FText>::FGetter::CreateRaw(this, &SK2Node_MethodsDropdown::GetCurrentText)));
 
 	return SNew(SHorizontalBox)
 		+ SHorizontalBox::Slot()
 		.AutoWidth()
 		[
 			SNew(SOverlay)
 			+ SOverlay::Slot()
 		[
 			SNew(SImage)
 			.Image_Raw(this, &SK2Node_MethodsDropdown::GetCurrentIconBrush)
 		]
 
 	+ SOverlay::Slot()
 		.VAlign(VAlign_Top)
 		.HAlign(HAlign_Right)
 		[
 			SNew(SImage)
 			// .Visibility_Raw(this, &::GetSpawnableIconOverlayVisibility)
 		.Image(FEditorStyle::GetBrush("Sequencer.SpawnableIconOverlay"))
 		]
 		]
 
 	+ SHorizontalBox::Slot()
 		.Padding(4.f, 0, 0, 0)
 		.VAlign(VAlign_Center)
 		[
 			TextContent
 		];
 }
 
 FText SK2Node_MethodsDropdown::GetCurrentText()
 {
 	if (auto node = Cast<UK2Node_WN_Await>(GraphNode))
 		if (node->CurrentFunction)
 			return node->CurrentFunction->GetDisplayNameText();
 
 	return LOCTEXT("SelectMethod", "Select method");
 }
 
 const FSlateBrush* SK2Node_MethodsDropdown::GetCurrentIconBrush() const
 {
 	return CurrentIcon.GetOptionalIcon();
 }
 
 void SK2Node_MethodsDropdown::SetMethodName(FName InName)
 {
 	if (UEdGraphPin* method_pin = GraphNode->FindPin("Method"))
 	{
 		const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
 
 		K2Schema->TrySetDefaultValue(*method_pin, InName.ToString());
 	}
 
 }
 
 FSlateColor SK2Node_MethodsDropdown::OnGetComboForeground() const
 {
 	return FSlateColor(FLinearColor(1.f, 1.f, 1.f, IsHovered() ? 1.f : 0.6f));
 }
 
 FSlateColor SK2Node_MethodsDropdown::OnGetWidgetForeground() const
 {
 	return FSlateColor(FLinearColor(1.f, 1.f, 1.f, IsHovered() ? 1.f : 0.15f));
 }
 
 FSlateColor SK2Node_MethodsDropdown::OnGetWidgetBackground() const
 {
 {
 	return FSlateColor(FLinearColor(1.f, 1.f, 1.f, IsHovered() ? 0.8f : 0.4f));
 }
 
 
 
 
 
 #undef LOCTEXT_NAMESPACE