CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Plugins/Runtime/PropertyAccess/Source/PropertyAccessEditor/Private/SPropertyBinding.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

1343 lines
41 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SPropertyBinding.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/SNullWidget.h"
#if WITH_EDITOR
#include "Engine/BlueprintGeneratedClass.h"
#endif // WITH_EDITOR
#include "DetailLayoutBuilder.h"
#include "Kismet2/BlueprintEditorUtils.h"
#include "ScopedTransaction.h"
#include "Widgets/Input/SNumericEntryBox.h"
#include "Widgets/Layout/SSpacer.h"
#include "UObject/UObjectIterator.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "BlueprintActionDatabase.h"
#include "Preferences/PersonaOptions.h"
#include "Styling/SlateTypes.h"
#define LOCTEXT_NAMESPACE "PropertyBinding"
/////////////////////////////////////////////////////
// SPropertyBinding
void SPropertyBinding::Construct(const FArguments& InArgs, UBlueprint* InBlueprint, const TArray<FBindingContextStruct>& InBindingContextStructs)
{
Blueprint = InBlueprint;
BindingContextStructs = InBindingContextStructs;
Args = InArgs._Args;
PropertyName = Args.Property != nullptr ? Args.Property->GetFName() : NAME_None;
for(int32 Index = 0; Index < BindingContextStructs.Num(); ++Index)
{
FBindingContextStruct& ContextStruct = BindingContextStructs[Index];
/* BindingContextStructSections contains an entry for each different FBindingContextStruct.Section.
Section are then further divided into subcategories based on the FBindingContextStruct.Category
Section are displayed as a section while subcategories are displayed as menu and submenu under a section. */
FBindingContextStructCategory* Section = BindingContextStructSections.FindByPredicate([&](const FBindingContextStructCategory& Section) { return Section.Name.IdenticalTo(ContextStruct.Section); });
if(!Section)
{
Section = &BindingContextStructSections.AddDefaulted_GetRef();
Section->Name = ContextStruct.Section;
}
//No category the BindingContextStruct will be displayed directly inside the section.
if (ContextStruct.Category.IsEmpty())
{
Section->BindingContextStructIndices.Add(Index);
}
else
{
// Parse the categories and subcategories and construct the data to build the menus.
TArray<FString> Categories;
ContextStruct.Category.ParseIntoArray(Categories, TEXT("|"));
BuildContextStructCategoryRecursive(Categories, Section->SubCategories, Index);
}
}
TSharedRef<SWidget> LinkIcon = Args.bUseLinkIconStyle ?
SNew(SBox)
.HeightOverride(16.0f)
[
SNew(SImage)
.Image(this, &SPropertyBinding::GetLinkIcon)
]
:
SNullWidget::NullWidget;
ChildSlot
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(SComboButton)
.ButtonStyle(Args.BindButtonStyle)
.ToolTipText(this, &SPropertyBinding::GetCurrentBindingToolTipText)
.OnGetMenuContent(this, &SPropertyBinding::OnGenerateDelegateMenu)
.ContentPadding(1)
.HasDownArrow(!Args.bUseLinkIconStyle)
.ButtonContent()
[
SNew(SHorizontalBox)
.Clipping(EWidgetClipping::ClipToBounds)
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
[
LinkIcon
]
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
[
SNew(SBox)
.HeightOverride(16.0f)
[
SNew(SImage)
.Image(this, &SPropertyBinding::GetCurrentBindingImage)
.ColorAndOpacity(this, &SPropertyBinding::GetCurrentBindingColor)
]
]
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(4, 0, 0, 0)
[
SNew(STextBlock)
.Text(this, &SPropertyBinding::GetCurrentBindingText)
.ColorAndOpacity(this, &SPropertyBinding::GetCurrentBindingTextColor)
.Font(IDetailLayoutBuilder::GetDetailFont())
]
]
]
+ SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SButton)
.ButtonStyle(FAppStyle::Get(), "HoverHintOnly")
.Visibility(this, &SPropertyBinding::GetGotoBindingVisibility)
.OnClicked(this, &SPropertyBinding::HandleGotoBindingClicked)
.VAlign(VAlign_Center)
.ToolTipText(LOCTEXT("GotoFunction", "Goto Function"))
[
SNew(SImage)
.Image(FAppStyle::GetBrush("Icons.Search"))
]
]
];
}
bool SPropertyBinding::IsClassDenied(UClass* InClass) const
{
if(Args.OnCanBindToClass.IsBound() && Args.OnCanBindToClass.Execute(InClass))
{
return false;
}
return true;
}
bool SPropertyBinding::IsFieldFromDeniedClass(FFieldVariant Field) const
{
return IsClassDenied(Field.GetOwnerClass());
}
template <typename Predicate>
void SPropertyBinding::ForEachBindableFunction(UClass* FromClass, Predicate Pred) const
{
if(Args.OnCanBindFunction.IsBound())
{
auto CheckBindableClass = [this, &Pred](UClass* InBindableClass)
{
// Early exit if this class is excluded by permissions
if ( !FBlueprintActionDatabase::IsClassAllowed(InBindableClass, FBlueprintActionDatabase::EPermissionsContext::Property) )
{
return;
}
// Walk up class hierarchy for native functions and properties
for ( TFieldIterator<UFunction> FuncIt(InBindableClass, EFieldIteratorFlags::IncludeSuper, EFieldIteratorFlags::ExcludeDeprecated, EFieldIteratorFlags::IncludeInterfaces); FuncIt; ++FuncIt )
{
UFunction* Function = *FuncIt;
// Stop processing functions after reaching a base class that it doesn't make sense to go beyond.
if ( IsFieldFromDeniedClass(Function) )
{
break;
}
// Only allow binding pure functions if we're limited to pure function bindings.
if ( Args.bGeneratePureBindings && !Function->HasAnyFunctionFlags(FUNC_Const | FUNC_BlueprintPure) )
{
continue;
}
// Only bind to functions that are callable from blueprints
if ( !UEdGraphSchema_K2::CanUserKismetCallFunction(Function) )
{
continue;
}
// Only bind to functions that are allowed by permissions
if ( !FBlueprintActionDatabase::IsFunctionAllowed(Function, FBlueprintActionDatabase::EPermissionsContext::Property) )
{
continue;
}
bool bValidObjectFunction = false;
if(Args.bAllowUObjectFunctions)
{
FObjectPropertyBase* ObjectPropertyBase = CastField<FObjectPropertyBase>(Function->GetReturnProperty());
if(ObjectPropertyBase != nullptr && Function->NumParms == 1)
{
bValidObjectFunction = true;
}
}
bool bValidStructFunction = false;
if(Args.bAllowStructFunctions)
{
FStructProperty* StructProperty = CastField<FStructProperty>(Function->GetReturnProperty());
if(StructProperty != nullptr && Function->NumParms == 1)
{
bValidStructFunction = true;
}
}
bool bValidThreadSafety = true;
if (Args.bAllowOnlyThreadSafeFunctions)
{
bValidThreadSafety = FBlueprintEditorUtils::HasFunctionBlueprintThreadSafeMetaData(Function);
}
if(bValidThreadSafety && (bValidObjectFunction || bValidStructFunction || Args.OnCanBindFunction.Execute(Function)))
{
Pred(FFunctionInfo(Function));
}
}
};
CheckBindableClass(FromClass);
if(Args.bAllowFunctionLibraryBindings)
{
// Iterate function libraries
for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
{
UClass* TestClass = *ClassIt;
if (TestClass->IsChildOf(UBlueprintFunctionLibrary::StaticClass()) && (!TestClass->HasAnyClassFlags(CLASS_Abstract)))
{
CheckBindableClass(TestClass);
}
}
}
}
}
void SPropertyBinding::AddCategoryToMenu(FMenuBuilder& MenuBuilder, const FBindingContextStructCategory& Category)
{
if (HasCategorySomethingToDisplayRecursive(Category))
{
TSharedRef<SWidget> SubMenu =
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SSpacer)
.Size(FVector2D(18.0f, 0.0f))
]
+ SHorizontalBox::Slot()
.AutoWidth()
[
SNew(STextBlock)
.Text(Category.Name)
];
MenuBuilder.AddSubMenu(SubMenu, FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillCategoryMenu, &Category));
}
}
void SPropertyBinding::BuildContextStructCategoryRecursive(TConstArrayView<FString> CategoryNames, TArray<FBindingContextStructCategory>& ParentSubCategories, int32 ContextStructIndex)
{
if (CategoryNames.IsEmpty())
{
return;
}
FString CategoryName = CategoryNames[0];
FBindingContextStructCategory* CategoryPtr = ParentSubCategories.FindByPredicate([&](const FBindingContextStructCategory& Category) { return Category.Name.ToString() == CategoryName; });
if (!CategoryPtr)
{
CategoryPtr = &ParentSubCategories.AddDefaulted_GetRef();
CategoryPtr->Name = FText::FromString(CategoryName);
}
if(CategoryNames.Num() == 1)
{
CategoryPtr->BindingContextStructIndices.Add(ContextStructIndex);
}
else
{
BuildContextStructCategoryRecursive(CategoryNames.RightChop(1), CategoryPtr->SubCategories, ContextStructIndex);
}
}
bool SPropertyBinding::HasCategorySomethingToDisplayRecursive(const FBindingContextStructCategory& Category) const
{
for(const FBindingContextStructCategory& SubCategory : Category.SubCategories)
{
if (HasCategorySomethingToDisplayRecursive(SubCategory))
{
return true;
}
}
for(const int32 ContextStructIndex : Category.BindingContextStructIndices)
{
const FBindingContextStruct& ContextStruct = BindingContextStructs[ContextStructIndex];
UStruct* Struct = const_cast<UStruct*>(ContextStruct.Struct);
PRAGMA_DISABLE_DEPRECATION_WARNINGS
const bool bDeprecatedCanBindToContextStruct = Args.OnCanBindToContextStruct.IsBound() && Args.OnCanBindToContextStruct.Execute(Struct);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
if (bDeprecatedCanBindToContextStruct || (Args.OnCanBindToContextStructWithIndex.IsBound() && Args.OnCanBindToContextStructWithIndex.Execute(Struct, ContextStructIndex)))
{
return true;
}
TArray<TSharedPtr<FBindingChainElement>> BindingChain;
BindingChain.Emplace(MakeShared<FBindingChainElement>(nullptr, ContextStructIndex));
if (HasBindableProperties(Struct, BindingChain))
{
return true;
}
}
return false;
}
TSharedRef<SWidget> SPropertyBinding::MakeContextStructWidget(const FBindingContextStruct& ContextStruct) const
{
const FText DisplayText = ContextStruct.DisplayText.IsEmpty() ? ContextStruct.Struct->GetDisplayNameText() : ContextStruct.DisplayText;
const FText ToolTipText = ContextStruct.TooltipText.IsEmpty() ? DisplayText : ContextStruct.TooltipText;
const FSlateBrush* Icon = ContextStruct.Icon;
FLinearColor IconColor = FLinearColor::White;
if (Icon == nullptr)
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
FEdGraphPinType PinType;
if (UClass* Class = Cast<UClass>(ContextStruct.Struct))
{
PinType.PinCategory = UEdGraphSchema_K2::PC_Object;
PinType.PinSubCategory = NAME_None;
PinType.PinSubCategoryObject = Class;
}
else if (UScriptStruct* ScriptStruct = Cast<UScriptStruct>(ContextStruct.Struct))
{
PinType.PinCategory = UEdGraphSchema_K2::PC_Struct;
PinType.PinSubCategory = NAME_None;
PinType.PinSubCategoryObject = ScriptStruct;
}
Icon = FBlueprintEditorUtils::GetIconFromPin(PinType, true);
IconColor = Schema->GetPinTypeColor(PinType);
}
if (ContextStruct.Color.IsSet())
{
IconColor = ContextStruct.Color.GetValue();
}
return SNew(SHorizontalBox)
.ToolTipText(ToolTipText)
+ SHorizontalBox::Slot()
.AutoWidth()
[SNew(SSpacer)
.Size(FVector2D(18.0f, 0.0f))]
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(1.0f, 0.0f)
[SNew(SImage)
.Image(Icon)
.ColorAndOpacity(IconColor)]
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(4.0f, 0.0f)
[SNew(STextBlock)
.Text(DisplayText)];
}
template <typename Predicate>
void SPropertyBinding::ForEachBindableProperty(UStruct* InStruct, const TArray<TSharedPtr<FBindingChainElement>>& BindingChain, Predicate Pred) const
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
const bool bIsOnCanBindPropertyBound = Args.OnCanBindProperty.IsBound() || Args.OnCanBindPropertyWithBindingChain.IsBound();
PRAGMA_ENABLE_DEPRECATION_WARNINGS
if(InStruct && bIsOnCanBindPropertyBound)
{
UBlueprintGeneratedClass* SkeletonClass = Blueprint ? Cast<UBlueprintGeneratedClass>(Blueprint->SkeletonGeneratedClass) : nullptr;
for ( TFieldIterator<FProperty> PropIt(InStruct, EFieldIteratorFlags::IncludeSuper); PropIt; ++PropIt )
{
FProperty* Property = *PropIt;
// Stop processing properties after reaching the stopped base class
if ( IsFieldFromDeniedClass(Property) )
{
break;
}
if (!CanAcceptPropertyOrChildren(Property, BindingChain))
{
continue;
}
if (SkeletonClass)
{
if (!UEdGraphSchema_K2::CanUserKismetAccessVariable(Property, SkeletonClass, UEdGraphSchema_K2::CannotBeDelegate))
{
continue;
}
}
// Also ignore advanced properties
if (Property->HasAnyPropertyFlags(CPF_AdvancedDisplay | CPF_EditorOnly))
{
continue;
}
// Exit if this property is excluded by permissions
if (!GetMutableDefault<UPersonaOptions>()->IsAllowedProperty(Property))
{
continue;
}
Pred(Property);
}
}
}
bool SPropertyBinding::HasBindableProperties(UStruct* InStruct, TArray<TSharedPtr<FBindingChainElement>>& BindingChain) const
{
TSet<UStruct*> VisitedStructs;
return HasBindablePropertiesRecursive(InStruct, VisitedStructs, BindingChain);
}
bool SPropertyBinding::HasBindablePropertiesRecursive(UStruct* InStruct, TSet<UStruct*>& VisitedStructs, TArray<TSharedPtr<FBindingChainElement>>& BindingChain) const
{
if (VisitedStructs.Contains(InStruct))
{
// If we have visited this struct already and it had bindable properties, it has been accounted for already.
// Returning false to allow early exit.
return false;
}
VisitedStructs.Add(InStruct);
// Arbitrary cut off to avoid infinite loops.
if (BindingChain.Num() > Args.MaxDepth)
{
return false;
}
int32 BindableCount = 0;
ForEachBindableProperty(InStruct, BindingChain, [this, &BindableCount, &VisitedStructs, &BindingChain] (FProperty* Property)
{
BindingChain.Emplace(MakeShared<FBindingChainElement>(Property));
ON_SCOPE_EXIT{ BindingChain.Pop(); };
FArrayProperty* ArrayProperty = CastField<FArrayProperty>(Property);
if(CanBindProperty(Property, BindingChain))
{
BindableCount++;
return;
}
if(Args.bAllowArrayElementBindings && ArrayProperty != nullptr)
{
BindingChain.Emplace(MakeShared<FBindingChainElement>(Property));
BindingChain.Last()->ArrayIndex = 0;
ON_SCOPE_EXIT{ BindingChain.Pop(); };
if(CanBindProperty(ArrayProperty->Inner, BindingChain))
{
BindableCount++;
return;
}
}
FProperty* InnerProperty = Property;
if(Args.bAllowArrayElementBindings && ArrayProperty != nullptr)
{
InnerProperty = ArrayProperty->Inner;
}
FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(InnerProperty);
FStructProperty* StructProperty = CastField<FStructProperty>(InnerProperty);
UStruct* Struct = nullptr;
UClass* Class = nullptr;
if ( ObjectProperty )
{
Struct = Class = ObjectProperty->PropertyClass;
}
else if ( StructProperty )
{
Struct = StructProperty->Struct;
}
if (Struct)
{
if (UStruct* ResolvedStruct = ResolveIndirection(BindingChain))
{
Struct = ResolvedStruct;
}
// Recurse into a struct, except if it is the same type as the one we're binding.
if (HasBindablePropertiesRecursive(Struct, VisitedStructs, BindingChain))
{
if (Class)
{
// Ignore any subobject properties that are not bindable.
// Also ignore any class that is explicitly on the deny list.
if (IsClassDenied(Class) || (Args.OnCanBindToSubObjectClass.IsBound() && Args.OnCanBindToSubObjectClass.Execute(Class)))
{
return;
}
}
if (Args.bAllowArrayElementBindings && ArrayProperty != nullptr)
{
BindableCount++;
}
else if (Args.bAllowStructMemberBindings)
{
BindableCount++;
}
}
}
});
if(UClass* Class = Cast<UClass>(InStruct))
{
ForEachBindableFunction(Class, [this, &BindableCount, &VisitedStructs, &BindingChain](const FFunctionInfo& Info)
{
BindingChain.Emplace(MakeShared<FBindingChainElement>(Info.Function));
ON_SCOPE_EXIT{ BindingChain.Pop(); };
FProperty* ReturnProperty = Info.Function->GetReturnProperty();
// We can get here if we accept non-leaf UObject functions, so if so we need to check the return value for compatibility
if(!Args.bAllowUObjectFunctions || CanBindProperty(ReturnProperty, BindingChain))
{
BindableCount++;
}
// Only show bindable subobjects, structs and variables if we're generating pure bindings.
if(Args.bGeneratePureBindings)
{
if(FObjectPropertyBase* ObjectPropertyBase = CastField<FObjectPropertyBase>(ReturnProperty))
{
if (HasBindablePropertiesRecursive(ObjectPropertyBase->PropertyClass, VisitedStructs, BindingChain))
{
if (Args.bAllowUObjectFunctions)
{
BindableCount++;
}
}
}
else if(FStructProperty* StructProperty = CastField<FStructProperty>(ReturnProperty))
{
if (HasBindablePropertiesRecursive(StructProperty->Struct, VisitedStructs, BindingChain))
{
BindableCount++;
}
}
}
});
}
return BindableCount > 0;
}
TSharedRef<SWidget> SPropertyBinding::OnGenerateDelegateMenu()
{
// The menu itself is be searchable.
const bool bSearchableMenu = true;
// The menu are generated through reflection and sometime the API exposes some recursivity (think about a Widget returning its parent which is also a Widget). Just by reflection
// it is not possible to determine when the root object is reached. It needs a kind of simulation which is not implemented. Also, even if the recursivity was correctly handled, the possible
// permutations tend to grow exponentially. Until a clever solution is found, the simple approach is to disable recursively searching those menus. User can still search the current one though.
const bool bRecursivelySearchableMenu = false;
const bool bInShouldCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder(bInShouldCloseWindowAfterMenuSelection, nullptr, Args.MenuExtender, /*bCloseSelfOnly*/false, &FCoreStyle::Get(), bSearchableMenu, NAME_None, bRecursivelySearchableMenu);
MenuBuilder.BeginSection("BindingActions", LOCTEXT("Bindings", "Bindings"));
if ( CanRemoveBinding() )
{
MenuBuilder.AddMenuEntry(
LOCTEXT("RemoveBinding", "Remove Binding"),
LOCTEXT("RemoveBindingToolTip", "Removes the current binding"),
FSlateIcon(FAppStyle::GetAppStyleSetName(), "Cross"),
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleRemoveBinding))
);
}
if(Args.bAllowNewBindings && Args.BindableSignature != nullptr)
{
MenuBuilder.AddMenuEntry(
LOCTEXT("CreateBinding", "Create Binding"),
LOCTEXT("CreateBindingToolTip", "Creates a new function on the widget blueprint that will return the binding data for this property."),
FSlateIcon(FAppStyle::GetAppStyleSetName(), "Plus"),
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleCreateAndAddBinding))
);
}
MenuBuilder.EndSection(); //CreateBinding
// Properties
{
// Get the current skeleton class, think header for the blueprint.
UBlueprintGeneratedClass* SkeletonClass = Blueprint ? Cast<UBlueprintGeneratedClass>(Blueprint->SkeletonGeneratedClass) : nullptr;
TArray<TSharedPtr<FBindingChainElement>> BindingChain;
FillPropertyMenu(MenuBuilder, SkeletonClass, BindingChain);
}
if (BindingContextStructs.Num() > 0)
{
// Go thought each top level section and display the sub categories as menu and then the context struct without categories.
for(const FBindingContextStructCategory& Section : BindingContextStructSections)
{
MenuBuilder.BeginSection(FName(), Section.Name);
for(const FBindingContextStructCategory& SubCategory : Section.SubCategories)
{
AddCategoryToMenu(MenuBuilder, SubCategory);
}
for (int32 Index : Section.BindingContextStructIndices)
{
FBindingContextStruct& ContextStruct = BindingContextStructs[Index];
// Make first chain element representing the index in the context array.
TArray<TSharedPtr<FBindingChainElement>> BindingChain;
BindingChain.Emplace(MakeShared<FBindingChainElement>(nullptr, Index));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
const bool bDeprecatedCanBindToContextStruct = Args.OnCanBindToContextStruct.IsBound() && Args.OnCanBindToContextStruct.Execute(ContextStruct.Struct);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
if (bDeprecatedCanBindToContextStruct || (Args.OnCanBindToContextStructWithIndex.IsBound() && Args.OnCanBindToContextStructWithIndex.Execute(ContextStruct.Struct, Index)))
{
// If the struct can be be bound to directly, create action for that.
MenuBuilder.AddMenuEntry(
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleAddBinding, BindingChain)),
MakeContextStructWidget(ContextStruct));
}
if (HasBindableProperties(ContextStruct.Struct, BindingChain))
{
// Show struct properties.
MenuBuilder.AddSubMenu(
MakeContextStructWidget(ContextStruct),
FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillPropertyMenu, ContextStruct.Struct, BindingChain));
}
}
MenuBuilder.EndSection();
}
}
FDisplayMetrics DisplayMetrics;
FSlateApplication::Get().GetCachedDisplayMetrics(DisplayMetrics);
return
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.MaxHeight(DisplayMetrics.PrimaryDisplayHeight * 0.5)
[
MenuBuilder.MakeWidget()
];
}
void SPropertyBinding::FillPropertyMenu(FMenuBuilder& MenuBuilder, UStruct* InOwnerStruct, TArray<TSharedPtr<FBindingChainElement>> InBindingChain)
{
auto MakeArrayElementPropertyWidget = [this](FProperty* InProperty, const TArray<TSharedPtr<FBindingChainElement>>& InNewBindingChain)
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
FEdGraphPinType PinType;
Schema->ConvertPropertyToPinType(InProperty, PinType);
TSharedPtr<FBindingChainElement> LeafElement = InNewBindingChain.Last();
return SNew(SHorizontalBox)
.ToolTipText(InProperty->GetToolTipText())
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SSpacer)
.Size(FVector2D(18.0f, 0.0f))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(1.0f, 0.0f)
[
SNew(SImage)
.Image(FBlueprintEditorUtils::GetIconFromPin(PinType, true))
.ColorAndOpacity(Schema->GetPinTypeColor(PinType))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(4.0f, 0.0f)
[
SNew(STextBlock)
.Text(FText::FromName(InProperty->GetFName()))
]
+SHorizontalBox::Slot()
.FillWidth(1.0f)
.HAlign(HAlign_Right)
.Padding(2.0f, 0.0f)
[
SNew(SBox)
.MinDesiredWidth(24.0f)
[
SNew(SNumericEntryBox<int32>)
.ToolTipText(LOCTEXT("ArrayIndex", "Array Index"))
.Value_Lambda([LeafElement](){ return LeafElement->ArrayIndex == INDEX_NONE ? TOptional<int32>() : TOptional<int32>(LeafElement->ArrayIndex); })
.OnValueCommitted(this, &SPropertyBinding::HandleSetBindingArrayIndex, InProperty, InNewBindingChain)
]
];
};
auto MakeArrayElementEntry = [this, &MenuBuilder, &MakeArrayElementPropertyWidget](FProperty* InProperty, const TArray<TSharedPtr<FBindingChainElement>>& InNewBindingChain)
{
MenuBuilder.AddMenuEntry(
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleAddBinding, InNewBindingChain)),
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
MakeArrayElementPropertyWidget(InProperty, InNewBindingChain)
]
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SSpacer)
.Size(FVector2D(15.0f, 0.0f))
]);
};
auto MakePropertyWidget = [this](FProperty* InProperty)
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
FEdGraphPinType PinType;
Schema->ConvertPropertyToPinType(InProperty, PinType);
FText PropertyDisplayName;
if(InProperty->IsNative())
{
if(const FString* ScriptNamePtr = InProperty->FindMetaData("ScriptName"))
{
PropertyDisplayName = FText::FromString(*ScriptNamePtr);
}
else
{
PropertyDisplayName = FText::FromString(InProperty->GetName());
}
}
else
{
PropertyDisplayName = FText::FromString(InProperty->GetDisplayNameText().ToString());
}
return SNew(SHorizontalBox)
.ToolTipText(InProperty->GetToolTipText())
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SSpacer)
.Size(FVector2D(18.0f, 0.0f))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(1.0f, 0.0f)
[
SNew(SImage)
.Image(FBlueprintEditorUtils::GetIconFromPin(PinType, true))
.ColorAndOpacity(Schema->GetPinTypeColor(PinType))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(4.0f, 0.0f)
[
SNew(STextBlock)
.Text(PropertyDisplayName)
];
};
auto MakePropertyEntry = [this, &MenuBuilder, &MakePropertyWidget](FProperty* InProperty, const TArray<TSharedPtr<FBindingChainElement>>& InNewBindingChain)
{
MenuBuilder.AddMenuEntry(
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleAddBinding, InNewBindingChain)),
MakePropertyWidget(InProperty));
};
auto MakeFunctionWidget = [this](const FFunctionInfo& Info)
{
static FName FunctionIcon(TEXT("GraphEditor.Function_16x"));
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
FEdGraphPinType PinType;
if(FProperty* ReturnProperty = Info.Function->GetReturnProperty())
{
Schema->ConvertPropertyToPinType(ReturnProperty, PinType);
}
return SNew(SHorizontalBox)
.ToolTipText(FText::FromString(Info.Tooltip))
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SSpacer)
.Size(FVector2D(18.0f, 0.0f))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(1.0f, 0.0f)
[
SNew(SImage)
.Image(FAppStyle::Get().GetBrush(FunctionIcon))
.ColorAndOpacity(Schema->GetPinTypeColor(PinType))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(4.0f, 0.0f)
[
SNew(STextBlock)
.Text(Info.DisplayName)
];
};
//---------------------------------------
// Function Bindings
if (Args.bAllowFunctionBindings)
{
if ( UClass* OwnerClass = Cast<UClass>(InOwnerStruct) )
{
static FName FunctionIcon(TEXT("GraphEditor.Function_16x"));
MenuBuilder.BeginSection("Functions", LOCTEXT("Functions", "Functions"));
{
ForEachBindableFunction(OwnerClass, [this, &InBindingChain, &MenuBuilder, &MakeFunctionWidget] (const FFunctionInfo& Info)
{
TArray<TSharedPtr<FBindingChainElement>> NewBindingChain(InBindingChain);
NewBindingChain.Emplace(MakeShared<FBindingChainElement>(Info.Function));
FProperty* ReturnProperty = Info.Function->GetReturnProperty();
// We can get here if we accept non-leaf UObject functions, so if so we need to check the return value for compatibility
if(!Args.bAllowUObjectFunctions || CanBindProperty(ReturnProperty, InBindingChain))
{
MenuBuilder.AddMenuEntry(
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleAddBinding, NewBindingChain)),
MakeFunctionWidget(Info));
}
// Only show bindable subobjects, structs and variables if we're generating pure bindings.
if(Args.bGeneratePureBindings)
{
if(FObjectPropertyBase* ObjectPropertyBase = CastField<FObjectPropertyBase>(ReturnProperty))
{
if (HasBindableProperties(ObjectPropertyBase->PropertyClass, NewBindingChain))
{
MenuBuilder.AddSubMenu(
MakeFunctionWidget(Info),
FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillPropertyMenu, static_cast<UStruct*>(ObjectPropertyBase->PropertyClass), NewBindingChain));
}
}
else if(FStructProperty* StructProperty = CastField<FStructProperty>(ReturnProperty))
{
if (HasBindableProperties(StructProperty->Struct, NewBindingChain))
{
MenuBuilder.AddSubMenu(
MakeFunctionWidget(Info),
FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillPropertyMenu, static_cast<UStruct*>(StructProperty->Struct), NewBindingChain));
}
}
}
});
}
MenuBuilder.EndSection(); //Functions
}
}
//---------------------------------------
// Property Bindings
// Only show bindable subobjects and variables if we're generating pure bindings.
if (Args.bGeneratePureBindings && Args.bAllowPropertyBindings)
{
FProperty* BindingProperty = nullptr;
if (Args.BindableSignature != nullptr)
{
BindingProperty = Args.BindableSignature->GetReturnProperty();
}
else
{
BindingProperty = Args.Property;
}
// Find the binder that can handle the delegate return type, don't bother allowing people
// to look for bindings that we don't support
if (CanBindProperty(BindingProperty, InBindingChain))
{
UStruct* BindingStruct = nullptr;
FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(BindingProperty);
FStructProperty* StructProperty = CastField<FStructProperty>(BindingProperty);
if (ObjectProperty)
{
BindingStruct = ObjectProperty->PropertyClass;
}
else if (StructProperty)
{
BindingStruct = StructProperty->Struct;
}
MenuBuilder.BeginSection("Properties", LOCTEXT("Properties", "Properties"));
{
ForEachBindableProperty(InOwnerStruct, InBindingChain, [this, &InBindingChain, BindingStruct, &MenuBuilder, &MakeArrayElementPropertyWidget, &MakePropertyWidget, &MakePropertyEntry, &MakeArrayElementEntry](FProperty* Property)
{
TArray<TSharedPtr<FBindingChainElement>> NewBindingChain(InBindingChain);
TArray<TSharedPtr<FBindingChainElement>> NewArrayElementBindingChain;
NewBindingChain.Emplace(MakeShared<FBindingChainElement>(Property));
if (CanBindProperty(Property, NewBindingChain))
{
MakePropertyEntry(Property, NewBindingChain);
}
FProperty* InnerProperty = Property;
FArrayProperty* ArrayProperty = CastField<FArrayProperty>(Property);
const bool bUseArrayProperty = Args.bAllowArrayElementBindings && ArrayProperty != nullptr;
if (bUseArrayProperty)
{
NewArrayElementBindingChain = InBindingChain;
NewArrayElementBindingChain.Emplace(MakeShared<FBindingChainElement>(Property));
NewArrayElementBindingChain.Last()->ArrayIndex = 0;
if (CanBindProperty(ArrayProperty->Inner, NewArrayElementBindingChain))
{
MakeArrayElementEntry(ArrayProperty->Inner, NewArrayElementBindingChain);
}
InnerProperty = ArrayProperty->Inner;
}
FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(InnerProperty);
FStructProperty* StructProperty = CastField<FStructProperty>(InnerProperty);
UStruct* Struct = nullptr;
UClass* Class = nullptr;
if (ObjectProperty)
{
Struct = Class = ObjectProperty->PropertyClass;
}
else if (StructProperty)
{
Struct = StructProperty->Struct;
}
// Recurse into a struct if it has some properties we can bind to.
if (Struct)
{
if (UStruct* ResolvedStruct = ResolveIndirection(NewBindingChain))
{
Struct = ResolvedStruct;
}
if (Class)
{
// Ignore any subobject properties that are not bindable.
// Also ignore any class that is explicitly on the deny list.
if (IsClassDenied(Class) || (Args.OnCanBindToSubObjectClass.IsBound() && Args.OnCanBindToSubObjectClass.Execute(Class)))
{
return;
}
}
TArray<TSharedPtr<FBindingChainElement>>& BindablePropertyBindingChain = bUseArrayProperty
? NewArrayElementBindingChain
: NewBindingChain;
if (HasBindableProperties(Struct, BindablePropertyBindingChain))
{
if (bUseArrayProperty)
{
MenuBuilder.AddSubMenu(
MakeArrayElementPropertyWidget(ArrayProperty->Inner, NewArrayElementBindingChain),
FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillPropertyMenu, Struct, NewArrayElementBindingChain)
);
}
else if (Args.bAllowStructMemberBindings)
{
MenuBuilder.AddSubMenu(
MakePropertyWidget(Property),
FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillPropertyMenu, Struct, NewBindingChain));
}
}
}
});
}
MenuBuilder.EndSection(); //Properties
}
}
// Add 'none' entry only if we just have the search block in the builder
if ( InOwnerStruct && MenuBuilder.GetMultiBox()->GetBlocks().Num() == 1 )
{
MenuBuilder.BeginSection("None", InOwnerStruct->GetDisplayNameText());
MenuBuilder.AddWidget(SNew(STextBlock).Text(LOCTEXT("None", "None")), FText::GetEmpty());
MenuBuilder.EndSection(); //None
}
}
void SPropertyBinding::FillCategoryMenu(FMenuBuilder& MenuBuilder, const FBindingContextStructCategory* Category)
{
MenuBuilder.BeginSection(NAME_None, Category->Name);
for (const FBindingContextStructCategory& SubCategory : Category->SubCategories)
{
AddCategoryToMenu(MenuBuilder, SubCategory);
}
for(int32 Index : Category->BindingContextStructIndices)
{
FBindingContextStruct& ContextStruct = BindingContextStructs[Index];
// Make first chain element representing the index in the context array.
TArray<TSharedPtr<FBindingChainElement>> BindingChain;
BindingChain.Emplace(MakeShared<FBindingChainElement>(nullptr, Index));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
const bool bDeprecatedCanBindToContextStruct = Args.OnCanBindToContextStruct.IsBound() && Args.OnCanBindToContextStruct.Execute(ContextStruct.Struct);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
if (bDeprecatedCanBindToContextStruct || (Args.OnCanBindToContextStructWithIndex.IsBound() && Args.OnCanBindToContextStructWithIndex.Execute(ContextStruct.Struct, Index)))
{
// If the struct can be be bound to directly, create action for that.
MenuBuilder.AddMenuEntry(
FUIAction(FExecuteAction::CreateSP(this, &SPropertyBinding::HandleAddBinding, BindingChain)),
MakeContextStructWidget(ContextStruct));
}
if (HasBindableProperties(ContextStruct.Struct, BindingChain))
{
// Show struct properties.
MenuBuilder.AddSubMenu(
MakeContextStructWidget(ContextStruct),
FNewMenuDelegate::CreateSP(this, &SPropertyBinding::FillPropertyMenu, ContextStruct.Struct, BindingChain));
}
}
MenuBuilder.EndSection();
}
const FSlateBrush* SPropertyBinding::GetLinkIcon() const
{
bool CheckState = HasAnyBindings();
return (CheckState) ? FAppStyle::GetBrush("Icons.Link") : FAppStyle::GetBrush("Icons.Unlink");
}
const FSlateBrush* SPropertyBinding::GetCurrentBindingImage() const
{
if(Args.CurrentBindingImage.IsSet())
{
return Args.CurrentBindingImage.Get();
}
return nullptr;
}
FText SPropertyBinding::GetCurrentBindingText() const
{
if(Args.CurrentBindingText.IsSet())
{
return Args.CurrentBindingText.Get();
}
return LOCTEXT("Bind", "Bind");
}
FSlateColor SPropertyBinding::GetCurrentBindingTextColor() const
{
if (Args.CurrentBindingTextColor.IsSet())
{
return Args.CurrentBindingTextColor.Get();
}
return FSlateColor::UseForeground();
}
FText SPropertyBinding::GetCurrentBindingToolTipText() const
{
if(Args.CurrentBindingToolTipText.IsSet())
{
return Args.CurrentBindingToolTipText.Get();
}
return GetCurrentBindingText();
}
FSlateColor SPropertyBinding::GetCurrentBindingColor() const
{
if(Args.CurrentBindingColor.IsSet())
{
return Args.CurrentBindingColor.Get();
}
return FLinearColor(0.25f, 0.25f, 0.25f);
}
bool SPropertyBinding::CanRemoveBinding()
{
if(Args.OnCanRemoveBinding.IsBound())
{
return Args.OnCanRemoveBinding.Execute(PropertyName);
}
return false;
}
void SPropertyBinding::HandleRemoveBinding()
{
if(Args.OnRemoveBinding.IsBound())
{
const FScopedTransaction Transaction(LOCTEXT("UnbindDelegate", "Remove Binding"));
Args.OnRemoveBinding.Execute(PropertyName);
}
}
void SPropertyBinding::HandleAddBinding(TArray<TSharedPtr<FBindingChainElement>> InBindingChain)
{
if(Args.OnAddBinding.IsBound())
{
const FScopedTransaction Transaction(LOCTEXT("BindDelegate", "Set Binding"));
TArray<FBindingChainElement> BindingChain;
BindingChain.Reserve(InBindingChain.Num());
Algo::Transform(InBindingChain, BindingChain, [](TSharedPtr<FBindingChainElement> InElement)
{
return *InElement.Get();
});
Args.OnAddBinding.Execute(PropertyName, BindingChain);
}
}
void SPropertyBinding::HandleSetBindingArrayIndex(int32 InArrayIndex, ETextCommit::Type InCommitType, FProperty* InProperty, TArray<TSharedPtr<FBindingChainElement>> InBindingChain)
{
InBindingChain.Last()->ArrayIndex = InArrayIndex;
// If the user hit enter on a compatible property, assume they want to accept
if(CanBindProperty(InProperty, InBindingChain) && InCommitType == ETextCommit::OnEnter)
{
HandleAddBinding(InBindingChain);
}
}
void SPropertyBinding::HandleCreateAndAddBinding()
{
if (!Blueprint)
{
return;
}
const FScopedTransaction Transaction(LOCTEXT("CreateDelegate", "Create Binding"));
Blueprint->Modify();
FString Pre = Args.bGeneratePureBindings ? FString(TEXT("Get")) : FString(TEXT("On"));
FString WidgetName;
if(Args.OnGenerateBindingName.IsBound())
{
WidgetName = Args.OnGenerateBindingName.Execute();
}
FString Post = (PropertyName != NAME_None) ? PropertyName.ToString() : FString();
Post.RemoveFromStart(TEXT("On"));
Post.RemoveFromEnd(TEXT("Event"));
// Create the function graph.
FString FunctionName = Pre + WidgetName + Post;
UEdGraph* FunctionGraph = FBlueprintEditorUtils::CreateNewGraph(
Blueprint,
FBlueprintEditorUtils::FindUniqueKismetName(Blueprint, FunctionName),
UEdGraph::StaticClass(),
UEdGraphSchema_K2::StaticClass());
const bool bUserCreated = true;
FBlueprintEditorUtils::AddFunctionGraph(Blueprint, FunctionGraph, bUserCreated, Args.BindableSignature);
UFunction* Function = Blueprint->SkeletonGeneratedClass->FindFunctionByName(FunctionGraph->GetFName());
check(Function);
Args.OnNewFunctionBindingCreated.ExecuteIfBound(FunctionGraph, Function);
// Add the binding to the blueprint
TArray<TSharedPtr<FBindingChainElement>> BindingPath;
BindingPath.Emplace(MakeShared<FBindingChainElement>(Function));
HandleAddBinding(BindingPath);
// Only mark bindings as pure that need to be.
if ( Args.bGeneratePureBindings )
{
const UEdGraphSchema_K2* Schema_K2 = Cast<UEdGraphSchema_K2>(FunctionGraph->GetSchema());
Schema_K2->AddExtraFunctionFlags(FunctionGraph, FUNC_BlueprintPure);
}
HandleGotoBindingClicked();
}
UStruct* SPropertyBinding::ResolveIndirection(const TArray<TSharedPtr<FBindingChainElement>>& InBindingChain) const
{
UStruct* ResolvedStruct = nullptr;
if (Args.OnResolveIndirection.IsBound())
{
TArray<FBindingChainElement> BindingChain;
BindingChain.Reserve(InBindingChain.Num());
Algo::Transform(InBindingChain, BindingChain, [](TSharedPtr<FBindingChainElement> InElement)
{
return *InElement.Get();
});
ResolvedStruct = Args.OnResolveIndirection.Execute(BindingChain);
}
return ResolvedStruct;
}
EVisibility SPropertyBinding::GetGotoBindingVisibility() const
{
if(Args.OnCanGotoBinding.IsBound())
{
if(Args.OnCanGotoBinding.Execute(PropertyName))
{
return EVisibility::Visible;
}
}
return EVisibility::Collapsed;
}
FReply SPropertyBinding::HandleGotoBindingClicked()
{
if(Args.OnGotoBinding.IsBound())
{
if(Args.OnGotoBinding.Execute(PropertyName))
{
return FReply::Handled();
}
}
return FReply::Unhandled();
}
bool SPropertyBinding::CanAcceptPropertyOrChildren(FProperty* InProperty, TConstArrayView<TSharedPtr<FBindingChainElement>> InBindingChain) const
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
if (Args.OnCanAcceptPropertyOrChildren.IsBound() && Args.OnCanAcceptPropertyOrChildren.Execute(InProperty) == false)
{
return false;
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
if (Args.OnCanAcceptPropertyOrChildrenWithBindingChain.IsBound())
{
TArray<FBindingChainElement, TInlineAllocator<32>> BindingChain;
Algo::Transform(InBindingChain, BindingChain, [](TSharedPtr<FBindingChainElement> InElement)
{
return *InElement.Get();
});
if (!Args.OnCanAcceptPropertyOrChildrenWithBindingChain.Execute(InProperty, BindingChain))
{
return false;
}
}
return true;
}
bool SPropertyBinding::CanBindProperty(FProperty* InProperty, TConstArrayView<TSharedPtr<FBindingChainElement>> InBindingChain) const
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
if (Args.OnCanBindProperty.IsBound() && Args.OnCanBindProperty.Execute(InProperty) == false)
{
return false;
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
if (Args.OnCanBindPropertyWithBindingChain.IsBound())
{
TArray<FBindingChainElement, TInlineAllocator<32>> BindingChain;
Algo::Transform(InBindingChain, BindingChain, [](TSharedPtr<FBindingChainElement> InElement)
{
return *InElement.Get();
});
if (!Args.OnCanBindPropertyWithBindingChain.Execute(InProperty, BindingChain))
{
return false;
}
}
return true;
}
FReply SPropertyBinding::OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
if (Args.OnDrop.IsBound())
{
return Args.OnDrop.Execute(MyGeometry, DragDropEvent);
}
return FReply::Unhandled();
}
bool SPropertyBinding::HasAnyBindings() const
{
if (Args.OnHasAnyBindings.IsBound())
{
return Args.OnHasAnyBindings.Execute();
}
return false;
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink