integration/Plugins/UEWingman/Source/UEWingman/Private/WingProperty.cpp

#include "WingProperty.h"
#include "WingUtils.h"
#include "WingServer.h"
#include "WingTypes.h"
#include "Engine/Blueprint.h"
#include "Materials/MaterialExpression.h"
#include "MaterialGraph/MaterialGraphNode.h"
#include "EdGraph/EdGraphPin.h"
#include "UObject/EnumProperty.h"

static bool IsPinTypeProperty(FProperty* Prop)
{
	FStructProperty* StructProp = CastField<FStructProperty>(Prop);
	return StructProp && StructProp->Struct == FEdGraphPinType::StaticStruct();
}

WingProperty::WingProperty(FProperty* InProp, void* InContainer)
	: Prop(InProp), Container(InContainer) {}

FString WingProperty::GetText() const
{
	void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(Container);
	if (IsPinTypeProperty(Prop))
		return UWingTypes::TypeToText(*static_cast<FEdGraphPinType*>(ValuePtr));
	FString Result;
	Prop->ExportTextItem_Direct(Result, ValuePtr, nullptr, nullptr, PPF_None);
	return Result;
}

bool WingProperty::TryParseEnum(UEnum* Enum, const FString& Text, int64 &OutValue)
{
	int Index = Enum->GetIndexByNameString(Text);
	if (Index == INDEX_NONE)
	{
		FString Prefix = Enum->GenerateEnumPrefix();
		if (!Prefix.IsEmpty())
		{
			Index = Enum->GetIndexByNameString(Prefix + TEXT("_") + Text);
		}
	}
	if (Index == INDEX_NONE)
	{
		UWingServer::Printf(TEXT("ERROR: '%s' is not a valid value for %s\n"),
			*Text, *Enum->GetName());
		OutValue = 0;
		return false;
	}
	else
	{
		OutValue = Enum->GetValueByIndex(Index);
		return true;
	}
}

bool WingProperty::TrySetText(const FString &Value)
{
	void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(Container);

	// Pin types get parsed by UWingTypes.
	if (IsPinTypeProperty(Prop))
		return UWingTypes::TextToType(Value, *static_cast<FEdGraphPinType*>(ValuePtr));

	// Byte Enum types get parsed by TryParseEnum, above.
	if (FByteProperty* ByteProp = CastField<FByteProperty>(Prop))
	{
		if (UEnum* Enum = ByteProp->Enum)
		{
			int64 EnumValue;
			if (!TryParseEnum(Enum, Value, EnumValue)) return false;
			ByteProp->SetPropertyValue(ValuePtr, (uint8)EnumValue);
			return true;
		}
	}

	// Regular Enum types get parsed by TryParseEnum, above.
	if (FEnumProperty* EnumProp = CastField<FEnumProperty>(Prop))
	{
		int64 EnumValue;
		if (!TryParseEnum(EnumProp->GetEnum(), Value, EnumValue)) return false;
		EnumProp->GetUnderlyingProperty()->SetIntPropertyValue(ValuePtr, EnumValue);
		return true;
	}

	// Non-enum properties use ImportText
	const TCHAR* Result = Prop->ImportText_Direct(*Value, ValuePtr, nullptr, PPF_None);
	if (!Result)
	{
		UWingServer::Printf(TEXT("ERROR: Failed to parse '%s' for property '%s' (type: %s)\n"),
			*Value, *WingUtils::FormatName(Prop), *Prop->GetCPPType());
		return false;
	}
	return true;
}

bool WingProperty::SetText(const FString& Value)
{
	if (!TrySetText(Value)) return false;

	if (Prop->GetOwnerClass()->IsChildOf(UMaterialExpression::StaticClass()))
	{
		UMaterialExpression* Expr = static_cast<UMaterialExpression*>(Container);
		Expr->ForcePropertyValueChanged(Prop);
	}

	return true;
}

void WingProperty::Collect(UStruct* StructType, void* Container, TArray<WingProperty> &Props, EPropertyFlags Flags)
{
	for (TFieldIterator<FProperty> It(StructType); It; ++It)
	{
		if (Flags != 0 && !It->HasAnyPropertyFlags(Flags)) continue;
		Props.Emplace(*It, Container);
	}
}

void WingProperty::Remove(TArray<WingProperty>& Props, const FString& Name)
{
	Props.RemoveAll([&](const WingProperty& P) { return P.Prop->GetName() == Name; });
}

TArray<WingProperty> WingProperty::GetAll(UObject* Obj, EPropertyFlags Flags)
{
	if (!Obj) return {};
	TArray<WingProperty> Result;

	// Blueprints don't have editable properties.  So
	// instead, we fetch properties from the generated CDO,
	// which is probably what the user intended.
	//
	if (UBlueprint *BP = ::Cast<UBlueprint>(Obj))
	{
		if (BP->GeneratedClass == nullptr)
		{
			UWingServer::Printf(TEXT("ERROR: Blueprint '%s' has no GeneratedClass\n"), *Obj->GetName());
			return {};
		}
		Obj = BP->GeneratedClass->GetDefaultObject();
	}

	Collect(Obj->GetClass(), Obj, Result, Flags);

	// If it's a Material Graph node, also collect properties from
	// the associated material expression.
	//
	if (UMaterialGraphNode* MatNode = Cast<UMaterialGraphNode>(Obj))
	{
		if (UMaterialExpression* Expr = MatNode->MaterialExpression)
		{
			Collect(Expr->GetClass(), Expr, Result, Flags);
		}
	}
	return Result;
}

TArray<WingProperty> WingProperty::GetAll(UStruct* StructType, void* Container, EPropertyFlags Flags)
{
	TArray<WingProperty> Result;
	Collect(StructType, Container, Result, Flags);
	return Result;
}

TArray<WingProperty> WingProperty::FindAllSubstring(const TArray<WingProperty>& Props, const FString& Substring)
{
	if (Substring.IsEmpty()) return Props;
	TArray<WingProperty> Result;
	for (const WingProperty& P : Props)
	{
		if (WingUtils::FormatName(P.Prop).Contains(Substring, ESearchCase::IgnoreCase))
			Result.Add(P);
	}
	return Result;
}

WingProperty WingProperty::FindOneExactMatch(const TArray<WingProperty>& Props, const FString& Name)
{
	TArray<WingProperty> Matches;
	for (const WingProperty& P : Props)
	{
		if (WingUtils::Identifies(Name, P.Prop))
			Matches.Add(P);
	}
	if (Matches.Num() == 0)
	{
		UWingServer::Printf(TEXT("ERROR: Property '%s' not found\n"), *Name);
		return WingProperty();
	}
	if (Matches.Num() > 1)
	{
		UWingServer::Printf(TEXT("ERROR: Ambiguous property '%s'\n"), *Name);
		return WingProperty();
	}
	return Matches[0];
}