/**
* Finds the event version of a UFunction for a given Blueprint
*
* @param InBlueprint The Blueprint to find the function within
* @param InFunction The Function to find an event version of
*
* @return Event Function used by the given Blueprint for the given Function
*/
UFunction* FindEventFunctionForClass(const UBlueprint* InBlueprint, const UFunction* InFunction)
{
// Look at all of the Blueprint parent's functions for an event
for (TFieldIterator<UFunction> FunctionIt(InBlueprint->ParentClass, EFieldIteratorFlags::IncludeSuper); FunctionIt; ++FunctionIt)
{
UFunction* Function = *FunctionIt;
if(Function->GetName() == InFunction->GetName())
{
return Function;
}
}
return NULL;
}
CefRefPtr<CefDictionaryValue> FWebJSScripting::ConvertObject(UObject* Object)
{
CefRefPtr<CefDictionaryValue> Result = CefDictionaryValue::Create();
RetainBinding(Object);
UClass* Class = Object->GetClass();
CefRefPtr<CefListValue> MethodNames = CefListValue::Create();
int32 MethodIndex = 0;
for (TFieldIterator<UFunction> FunctionIt(Class, EFieldIteratorFlags::IncludeSuper); FunctionIt; ++FunctionIt)
{
UFunction* Function = *FunctionIt;
MethodNames->SetString(MethodIndex++, *Function->GetName());
}
Result->SetString("$type", "uobject");
Result->SetString("$id", *PtrToGuid(Object).ToString(EGuidFormats::Digits));
Result->SetList("$methods", MethodNames);
return Result;
}
/**
* Checks if the passed in function is available as an event for the Blueprint
*
* @param InBlueprint The Blueprint to check for validity with
* @param InFunction The Function to check for being available as an event
*
* @return Returns true if the function is available as an event in the Blueprint
*/
bool IsFunctionAvailableAsEvent(const UBlueprint* InBlueprint, const UFunction* InFunction)
{
// Build a list of all interface classes either implemented by this blueprint or through inheritance
TArray<UClass*> InterfaceClasses;
FBlueprintEditorUtils::FindImplementedInterfaces(InBlueprint, true, InterfaceClasses);
InterfaceClasses.Add(InBlueprint->ParentClass);
// Grab the list of events to be excluded from the override list
const FString ExclusionListKeyName = TEXT("KismetHideOverrides");
TArray<FString> ExcludedEventNames;
if( InBlueprint->ParentClass->HasMetaData(*ExclusionListKeyName) )
{
const FString ExcludedEventNameString = InBlueprint->ParentClass->GetMetaData(*ExclusionListKeyName);
ExcludedEventNameString.ParseIntoArray(ExcludedEventNames, TEXT(","), true);
}
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
if (K2Schema->FunctionCanBePlacedAsEvent(InFunction) && !ExcludedEventNames.Contains(InFunction->GetName()))
{
// Check all potential interface events using the class list we build above
for(auto It = InterfaceClasses.CreateConstIterator(); It; It++)
{
const UClass* Interface = (*It);
for (TFieldIterator<UFunction> FunctionIt(Interface, EFieldIteratorFlags::IncludeSuper); FunctionIt; ++FunctionIt)
{
UFunction* Function = *FunctionIt;
if(Function->GetName() == InFunction->GetName())
{
return true;
}
}
}
}
return false;
}
//------------------------------------------------------------------------------
static int32 GetHiddenFunctions(uint32 Indent, UClass* Class, bool bShowFunLibs, FString& JsonOut)
{
int32 HiddenFuncCount = 0;
FString IndentString = GetIndentString(Indent);
JsonOut += IndentString + TEXT("\"HiddenFunctions\" : [");
FString& OutputString = JsonOut;
UClass* CallingClass = Class;
auto FindHiddenFuncs = [&IndentString, &CallingClass, &HiddenFuncCount, &OutputString] (UClass* FunctionClass)
{
for (TFieldIterator<UFunction> FunctionIt(FunctionClass, EFieldIteratorFlags::IncludeSuper); FunctionIt; ++FunctionIt)
{
UFunction* Function = *FunctionIt;
if (FObjectEditorUtils::IsFunctionHiddenFromClass(Function, CallingClass))
{
++HiddenFuncCount;
OutputString += TEXT("\n\t") + IndentString + TEXT("\"") + Function->GetPathName() + TEXT("\",");
}
}
/*for (TFieldIterator<UObjectProperty> PropIt(FuncClass, EFieldIteratorFlags::IncludeSuper); PropIt; ++PropIt)
{
UClass* PropClass = PropIt->PropertyClass;
for (TFieldIterator<UFunction> FunctionIt(PropClass, EFieldIteratorFlags::IncludeSuper); FunctionIt; ++FunctionIt)
{
if (FObjectEditorUtils::IsFunctionHiddenFromClass(*FunctionIt, ThisClass))
{
++HiddenFuncCount;
OutputString += TEXT("\n\t\t\t\"") + FunctionIt->GetPathName() + TEXT("\",");
}
}
}*/
};
FindHiddenFuncs(CallingClass); // find all this class's functions
if (bShowFunLibs)
{
for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt) // find all functions in each function library
{
UClass* TestClass = *ClassIt;
// if this is a skeleton class, don't bother
if (FKismetEditorUtilities::IsClassABlueprintSkeleton(TestClass))
{
continue;
}
if (TestClass->IsChildOf(UBlueprintFunctionLibrary::StaticClass()))
{
FindHiddenFuncs(TestClass);
}
}
}
if (HiddenFuncCount > 0)
{
OutputString.RemoveAt(OutputString.Len() - 1); // remove the last comma
}
OutputString += TEXT("\n") + IndentString + TEXT("]");
return HiddenFuncCount;
}
