UE Wingman renaming complete.

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

@@ -0,0 +1,194 @@
+#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];
+}