795 lines
24 KiB
C++
795 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "ItemPropertyNode.h"
|
|
#include "Editor.h"
|
|
#include "EditorMetadataOverrides.h"
|
|
#include "ObjectPropertyNode.h"
|
|
#include "PropertyEditorHelpers.h"
|
|
#include "PropertyPathHelpers.h"
|
|
#include "Settings/EditorStyleSettings.h"
|
|
#include "UserInterface/PropertyEditor/SPropertyEditorArrayItem.h"
|
|
|
|
#include "UObject/PropertyOptional.h"
|
|
#include "VerseVM/VVMCVars.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "ItemPropertyNode"
|
|
|
|
FItemPropertyNode::FItemPropertyNode()
|
|
{
|
|
bCanDisplayFavorite = false;
|
|
}
|
|
|
|
FItemPropertyNode::~FItemPropertyNode()
|
|
{
|
|
|
|
}
|
|
|
|
uint8* FItemPropertyNode::GetValueBaseAddress(uint8* StartAddress, bool bIsSparseData, bool bIsStruct) const
|
|
{
|
|
const FProperty* MyProperty = GetProperty();
|
|
const TSharedPtr<FPropertyNode> ParentNode = ParentNodeWeakPtr.Pin();
|
|
if (MyProperty && ParentNode)
|
|
{
|
|
const FArrayProperty* OuterArrayProp = MyProperty->GetOwner<FArrayProperty>();
|
|
const FSetProperty* OuterSetProp = MyProperty->GetOwner<FSetProperty>();
|
|
const FMapProperty* OuterMapProp = MyProperty->GetOwner<FMapProperty>();
|
|
|
|
uint8* ValueBaseAddress = ParentNode->GetValueBaseAddress(StartAddress, bIsSparseData, bIsStruct);
|
|
|
|
if (OuterArrayProp != nullptr)
|
|
{
|
|
FScriptArrayHelper ArrayHelper(OuterArrayProp, ValueBaseAddress);
|
|
if (ValueBaseAddress != nullptr && ArrayHelper.IsValidIndex(ArrayIndex))
|
|
{
|
|
return ArrayHelper.GetRawPtr(ArrayIndex);
|
|
}
|
|
}
|
|
else if (OuterSetProp != nullptr)
|
|
{
|
|
FScriptSetHelper SetHelper(OuterSetProp, ValueBaseAddress);
|
|
if (ValueBaseAddress != nullptr)
|
|
{
|
|
int32 ActualIndex = SetHelper.FindInternalIndex(ArrayIndex);
|
|
if (ActualIndex != INDEX_NONE)
|
|
{
|
|
return SetHelper.GetElementPtr(ActualIndex);
|
|
}
|
|
}
|
|
}
|
|
else if (OuterMapProp != nullptr)
|
|
{
|
|
FScriptMapHelper MapHelper(OuterMapProp, ValueBaseAddress);
|
|
if (ValueBaseAddress != nullptr)
|
|
{
|
|
int32 ActualIndex = MapHelper.FindInternalIndex(ArrayIndex);
|
|
if (ActualIndex != INDEX_NONE)
|
|
{
|
|
uint8* PairPtr = MapHelper.GetPairPtr(ActualIndex);
|
|
return MyProperty->ContainerPtrToValuePtr<uint8>(PairPtr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint8* ValueAddress = ValueBaseAddress;
|
|
if (ValueAddress != nullptr && ParentNode->GetProperty() != MyProperty)
|
|
{
|
|
// if this is not a fixed size array (in which the parent property and this property are the same), we need to offset from the property (otherwise, the parent already did that for us)
|
|
ValueAddress = MyProperty->ContainerPtrToValuePtr<uint8>(ValueAddress);
|
|
}
|
|
|
|
if (ValueAddress != nullptr)
|
|
{
|
|
ValueAddress += ArrayOffset;
|
|
}
|
|
return ValueAddress;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
uint8* FItemPropertyNode::GetValueAddress(uint8* StartAddress, bool bIsSparseData, bool bIsStruct) const
|
|
{
|
|
uint8* Result = GetValueBaseAddress(StartAddress, bIsSparseData, bIsStruct);
|
|
return Result;
|
|
}
|
|
|
|
/**
|
|
* Overridden function for special setup
|
|
*/
|
|
void FItemPropertyNode::InitBeforeNodeFlags()
|
|
{
|
|
FPropertyNode::InitBeforeNodeFlags();
|
|
|
|
const FProperty* MyProperty = Property.Get();
|
|
const FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(MyProperty);
|
|
|
|
if (ObjectProperty)
|
|
{
|
|
if (Verse::CVarUseDynamicSubobjectInstancing->GetBool())
|
|
{
|
|
if (ObjectProperty->GetOwnerClass()->ShouldUseDynamicSubobjectInstancing())
|
|
{
|
|
SetNodeFlags(EPropertyNodeFlags::SupportsDynamicInstancing, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
static const FName Name_SupportsDynamicInstance("SupportsDynamicInstance");
|
|
|
|
if (ObjectProperty->HasMetaData(Name_SupportsDynamicInstance))
|
|
{
|
|
SetNodeFlags(EPropertyNodeFlags::SupportsDynamicInstancing, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FItemPropertyNode::InitExpansionFlags(void)
|
|
{
|
|
FProperty* MyProperty = GetProperty();
|
|
|
|
bool bExpandableType = CastField<FStructProperty>(MyProperty)
|
|
|| CastField<FArrayProperty>(MyProperty)
|
|
|| CastField<FSetProperty>(MyProperty)
|
|
|| CastField<FMapProperty>(MyProperty)
|
|
|| CastField<FOptionalProperty>(MyProperty);
|
|
|
|
auto IsDynamicInstanced = [this, MyProperty]()
|
|
{
|
|
if (!HasNodeFlags(EPropertyNodeFlags::SupportsDynamicInstancing))
|
|
{
|
|
return false;
|
|
}
|
|
// Handle dynamic instancing
|
|
// The property will instance the object under it only if that object is within this object's outer
|
|
// otherwise the object will be a reference
|
|
// The Property tree needs to dead end the generation of PropertyNodes for references to objects otherwise initializing
|
|
// the child nodes amounts to effectively enumerating all paths to a given property on the referenced object which can have considerable
|
|
// performance and memory issues
|
|
FObjectProperty* ObjectProperty = CastField<FObjectProperty>(MyProperty);
|
|
if (!ObjectProperty)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Walk up the PropertyNode tree to find the nearest ObjectNode, this will be the outer we check against
|
|
const FObjectPropertyNode* ParentObjectNode = FindObjectItemParent();
|
|
if (!ParentObjectNode)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FReadAddressList ObjectAddresses;
|
|
if( !GetReadAddress(!!HasNodeFlags(EPropertyNodeFlags::SingleSelectOnly), ObjectAddresses, false ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (ParentObjectNode->GetNumObjects() != ObjectAddresses.Num())
|
|
{
|
|
// Cannot establish a one-to-one mapping of objects, so it is not possible to determine if the object is dynamic instanced
|
|
return false;
|
|
}
|
|
|
|
// We've got some addresses, and we know they're all NULL or non-NULL.
|
|
// Have a peek at them and check if they are instanced. They must all be instanced otherwise we dead-end the node expansion
|
|
for (int32 i = 0; i < ObjectAddresses.Num(); i++)
|
|
{
|
|
const UObject* Outer = ParentObjectNode->GetUObject(i);
|
|
UObject* Obj = ObjectProperty->GetObjectPropertyValue(ObjectAddresses.GetAddress(i));
|
|
if(Outer != nullptr && Obj != nullptr)
|
|
{
|
|
if (!Obj->IsInOuter(Outer))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
const bool bIsDynamicInstanced = IsDynamicInstanced();
|
|
if (bIsDynamicInstanced)
|
|
{
|
|
SetNodeFlags(EPropertyNodeFlags::DynamicInstance, true);
|
|
bExpandableType = true;
|
|
}
|
|
|
|
if (bExpandableType
|
|
|| HasNodeFlags(EPropertyNodeFlags::EditInlineNew)
|
|
|| HasNodeFlags(EPropertyNodeFlags::ShowInnerObjectProperties)
|
|
|| (MyProperty->ArrayDim > 1 && ArrayIndex == -1))
|
|
{
|
|
SetNodeFlags(EPropertyNodeFlags::CanBeExpanded, true);
|
|
}
|
|
}
|
|
/**
|
|
* Overridden function for Creating Child Nodes
|
|
*/
|
|
void FItemPropertyNode::InitChildNodes()
|
|
{
|
|
//NOTE - this is only turned off as to not invalidate child object nodes.
|
|
FProperty* MyProperty = GetProperty();
|
|
FStructProperty* StructProperty = CastField<FStructProperty>(MyProperty);
|
|
FArrayProperty* ArrayProperty = CastField<FArrayProperty>(MyProperty);
|
|
FSetProperty* SetProperty = CastField<FSetProperty>(MyProperty);
|
|
FMapProperty* MapProperty = CastField<FMapProperty>(MyProperty);
|
|
FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(MyProperty);
|
|
FOptionalProperty* OptionalProperty = CastField<FOptionalProperty>(MyProperty);
|
|
|
|
const bool bShouldShowHiddenProperties = !!HasNodeFlags(EPropertyNodeFlags::ShouldShowHiddenProperties);
|
|
const bool bShouldShowDisableEditOnInstance = !!HasNodeFlags(EPropertyNodeFlags::ShouldShowDisableEditOnInstance);
|
|
|
|
if( MyProperty->ArrayDim > 1 && ArrayIndex == -1 )
|
|
{
|
|
// Do not add array children which are defined by an enum but the enum at the array index is hidden
|
|
// This only applies to static arrays
|
|
static const FName NAME_ArraySizeEnum("ArraySizeEnum");
|
|
UEnum* ArraySizeEnum = NULL;
|
|
if (MyProperty->HasMetaData(NAME_ArraySizeEnum))
|
|
{
|
|
ArraySizeEnum = FindObject<UEnum>(NULL, *MyProperty->GetMetaData(NAME_ArraySizeEnum));
|
|
}
|
|
|
|
// Expand array.
|
|
for( int32 Index = 0 ; Index < MyProperty->ArrayDim ; Index++ )
|
|
{
|
|
bool bShouldBeHidden = false;
|
|
if( ArraySizeEnum )
|
|
{
|
|
// The enum at this array index is hidden
|
|
bShouldBeHidden = ArraySizeEnum->HasMetaData(TEXT("Hidden"), Index );
|
|
}
|
|
|
|
if( !bShouldBeHidden )
|
|
{
|
|
TSharedPtr<FItemPropertyNode> NewItemNode( new FItemPropertyNode);
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = MyProperty;
|
|
InitParams.ArrayOffset = Index*MyProperty->GetElementSize();
|
|
InitParams.ArrayIndex = Index;
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties;
|
|
InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance;
|
|
|
|
NewItemNode->InitNode( InitParams );
|
|
AddChildNode(NewItemNode);
|
|
}
|
|
}
|
|
}
|
|
else if( ArrayProperty )
|
|
{
|
|
void* Array = NULL;
|
|
FReadAddressList Addresses;
|
|
if ( GetReadAddress(HasNodeFlags(EPropertyNodeFlags::SingleSelectOnly), Addresses ) )
|
|
{
|
|
Array = Addresses.GetAddress(0);
|
|
}
|
|
|
|
if( Array )
|
|
{
|
|
FScriptArrayHelper ArrayHelper(ArrayProperty, Array);
|
|
for( int32 Index = 0 ; Index < ArrayHelper.Num(); Index++ )
|
|
{
|
|
TSharedPtr<FItemPropertyNode> NewItemNode( new FItemPropertyNode );
|
|
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = ArrayProperty->Inner;
|
|
InitParams.ArrayOffset = Index * ArrayProperty->Inner->GetElementSize();
|
|
InitParams.ArrayIndex = Index;
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties;
|
|
InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance;
|
|
|
|
NewItemNode->InitNode( InitParams );
|
|
AddChildNode(NewItemNode);
|
|
}
|
|
}
|
|
}
|
|
else if ( SetProperty )
|
|
{
|
|
void* Set = NULL;
|
|
FReadAddressList Addresses;
|
|
if (GetReadAddress(!!HasNodeFlags(EPropertyNodeFlags::SingleSelectOnly), Addresses))
|
|
{
|
|
Set = Addresses.GetAddress(0);
|
|
}
|
|
|
|
if (Set)
|
|
{
|
|
FScriptSetHelper SetHelper(SetProperty, Set);
|
|
|
|
for (int32 Index = 0; Index < SetHelper.Num(); ++Index)
|
|
{
|
|
TSharedPtr<FItemPropertyNode> NewItemNode(new FItemPropertyNode);
|
|
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = SetProperty->ElementProp;
|
|
InitParams.ArrayIndex = Index;
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties;
|
|
InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance;
|
|
|
|
NewItemNode->InitNode(InitParams);
|
|
AddChildNode(NewItemNode);
|
|
}
|
|
}
|
|
}
|
|
else if ( MapProperty )
|
|
{
|
|
void* Map = NULL;
|
|
FReadAddressList Addresses;
|
|
if (GetReadAddress(!!HasNodeFlags(EPropertyNodeFlags::SingleSelectOnly), Addresses))
|
|
{
|
|
Map = Addresses.GetAddress(0);
|
|
}
|
|
|
|
if ( Map )
|
|
{
|
|
FScriptMapHelper MapHelper(MapProperty, Map);
|
|
|
|
for (int32 Index = 0; Index < MapHelper.Num(); ++Index)
|
|
{
|
|
// Construct the key node first
|
|
TSharedPtr<FPropertyNode> KeyNode(new FItemPropertyNode());
|
|
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this); // Key Node needs to point to this node to ensure its data is set correctly
|
|
InitParams.Property = MapHelper.KeyProp;
|
|
InitParams.ArrayIndex = Index;
|
|
InitParams.ArrayOffset = 0;
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties;
|
|
InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance;
|
|
|
|
KeyNode->InitNode(InitParams);
|
|
// Not adding the key node as a child, otherwise it'll show up in the wrong spot.
|
|
|
|
// Then the value node
|
|
TSharedPtr<FPropertyNode> ValueNode(new FItemPropertyNode());
|
|
|
|
// Reuse the init params
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = MapHelper.ValueProp;
|
|
|
|
ValueNode->InitNode(InitParams);
|
|
AddChildNode(ValueNode);
|
|
|
|
FPropertyNode::SetupKeyValueNodePair(KeyNode, ValueNode);
|
|
}
|
|
}
|
|
}
|
|
else if( StructProperty )
|
|
{
|
|
// Expand struct.
|
|
TArray<FProperty*> StructMembers;
|
|
for (TFieldIterator<FProperty> It(StructProperty->Struct); It; ++It)
|
|
{
|
|
FProperty* StructMember = *It;
|
|
|
|
if (PropertyEditorHelpers::ShouldBeVisible(*this, StructMember))
|
|
{
|
|
StructMembers.Add(StructMember);
|
|
}
|
|
}
|
|
|
|
PropertyEditorHelpers::OrderPropertiesFromMetadata(StructMembers);
|
|
|
|
for (FProperty* StructMember : StructMembers)
|
|
{
|
|
TSharedPtr<FItemPropertyNode> NewItemNode( new FItemPropertyNode );
|
|
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = StructMember;
|
|
InitParams.ArrayOffset = 0;
|
|
InitParams.ArrayIndex = INDEX_NONE;
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties;
|
|
InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance;
|
|
|
|
NewItemNode->InitNode( InitParams );
|
|
AddChildNode(NewItemNode);
|
|
|
|
if ( FPropertySettings::Get().ExpandDistributions() == false)
|
|
{
|
|
// auto-expand distribution structs
|
|
if ( CastField<FObjectProperty>(StructMember) || CastField<FWeakObjectProperty>(StructMember) || CastField<FLazyObjectProperty>(StructMember) || CastField<FSoftObjectProperty>(StructMember) )
|
|
{
|
|
const FName StructName = StructProperty->Struct->GetFName();
|
|
if (StructName == NAME_RawDistributionFloat || StructName == NAME_RawDistributionVector)
|
|
{
|
|
NewItemNode->SetNodeFlags(EPropertyNodeFlags::Expanded, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if( ObjectProperty )
|
|
{
|
|
uint8* ReadValue = NULL;
|
|
|
|
FReadAddressList ReadAddresses;
|
|
if( GetReadAddress(!!HasNodeFlags(EPropertyNodeFlags::SingleSelectOnly), ReadAddresses, false ) )
|
|
{
|
|
// We've got some addresses, and we know they're all NULL or non-NULL.
|
|
// Have a peek at the first one, and only build an objects node if we've got addresses.
|
|
if( UObject* Obj = (ReadAddresses.Num() > 0) ? ObjectProperty->GetObjectPropertyValue(ReadAddresses.GetAddress(0)) : nullptr )
|
|
{
|
|
//verify it's not above in the hierarchy somewhere
|
|
FObjectPropertyNode* ParentObjectNode = FindObjectItemParent();
|
|
while (ParentObjectNode)
|
|
{
|
|
for ( TPropObjectIterator Itor( ParentObjectNode->ObjectIterator() ) ; Itor ; ++Itor )
|
|
{
|
|
if (*Itor == Obj)
|
|
{
|
|
SetNodeFlags(EPropertyNodeFlags::NoChildrenDueToCircularReference, true);
|
|
//stop the circular loop!!!
|
|
return;
|
|
}
|
|
}
|
|
FPropertyNode* UpwardTravesalNode = ParentObjectNode->GetParentNode();
|
|
ParentObjectNode = (UpwardTravesalNode==NULL) ? NULL : UpwardTravesalNode->FindObjectItemParent();
|
|
}
|
|
|
|
|
|
TSharedPtr<FObjectPropertyNode> NewObjectNode( new FObjectPropertyNode );
|
|
for ( int32 AddressIndex = 0 ; AddressIndex < ReadAddresses.Num() ; ++AddressIndex )
|
|
{
|
|
NewObjectNode->AddObject( ObjectProperty->GetObjectPropertyValue(ReadAddresses.GetAddress(AddressIndex) ) );
|
|
}
|
|
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = MyProperty;
|
|
InitParams.ArrayOffset = 0;
|
|
InitParams.ArrayIndex = INDEX_NONE;
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties;
|
|
InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance;
|
|
|
|
NewObjectNode->InitNode( InitParams );
|
|
AddChildNode(NewObjectNode);
|
|
}
|
|
}
|
|
}
|
|
else if (OptionalProperty)
|
|
{
|
|
void* Optional = NULL;
|
|
FReadAddressList Addresses;
|
|
if (GetReadAddress(Addresses))
|
|
{
|
|
for (int i = 0; i < Addresses.Num(); i++)
|
|
{
|
|
Optional = Addresses.GetAddress(i);
|
|
if (OptionalProperty->IsSet(Optional))
|
|
{
|
|
TSharedPtr<FItemPropertyNode> ValueNode = MakeShared<FItemPropertyNode>();
|
|
|
|
FPropertyNodeInitParams InitParams;
|
|
InitParams.ParentNode = SharedThis(this);
|
|
InitParams.Property = OptionalProperty->GetValueProperty();
|
|
InitParams.bAllowChildren = true;
|
|
InitParams.bForceHiddenPropertyVisibility = !!HasNodeFlags(EPropertyNodeFlags::ShouldShowHiddenProperties);
|
|
InitParams.bCreateDisableEditOnInstanceNodes = !!HasNodeFlags(EPropertyNodeFlags::ShouldShowDisableEditOnInstance);
|
|
|
|
ValueNode->InitNode(InitParams);
|
|
AddChildNode(ValueNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FItemPropertyNode::SetFavorite(bool IsFavorite)
|
|
{
|
|
if (GEditor == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
UEditorMetadataOverrides* MetadataOverrides = GEditor->GetEditorSubsystem<UEditorMetadataOverrides>();
|
|
if (MetadataOverrides == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const FObjectPropertyNode* ObjectParent = FindObjectItemParent();
|
|
if (ObjectParent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FString Path;
|
|
GetQualifiedName(Path, /*bWithArrayIndex=*/true, ObjectParent, /*bIgnoreCategories=*/true);
|
|
|
|
static const FName FavoritePropertiesName("FavoriteProperties");
|
|
|
|
TArray<FString> FavoritePropertiesList;
|
|
if (MetadataOverrides->GetArrayMetadata(ObjectParent->GetObjectBaseClass(), FavoritePropertiesName, FavoritePropertiesList))
|
|
{
|
|
if (IsFavorite)
|
|
{
|
|
FavoritePropertiesList.AddUnique(Path);
|
|
}
|
|
else
|
|
{
|
|
FavoritePropertiesList.Remove(Path);
|
|
}
|
|
|
|
MetadataOverrides->SetArrayMetadata(ObjectParent->GetObjectBaseClass(), FavoritePropertiesName, FavoritePropertiesList);
|
|
}
|
|
else
|
|
{
|
|
if (IsFavorite)
|
|
{
|
|
FavoritePropertiesList.Add(Path);
|
|
MetadataOverrides->SetArrayMetadata(ObjectParent->GetObjectBaseClass(), FavoritePropertiesName, FavoritePropertiesList);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FItemPropertyNode::IsFavorite() const
|
|
{
|
|
if (GEditor == nullptr)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
UEditorMetadataOverrides* MetadataOverrides = GEditor->GetEditorSubsystem<UEditorMetadataOverrides>();
|
|
if (MetadataOverrides == nullptr)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const FObjectPropertyNode* ObjectParent = FindObjectItemParent();
|
|
if (ObjectParent == nullptr)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FString Path;
|
|
GetQualifiedName(Path, /*bWithArrayIndex=*/true, ObjectParent, /*bIgnoreCategories=*/true);
|
|
|
|
static const FName FavoritePropertiesName("FavoriteProperties");
|
|
|
|
TArray<FString> FavoritePropertiesList;
|
|
if (MetadataOverrides->GetArrayMetadata(ObjectParent->GetObjectBaseClass(), FavoritePropertiesName, FavoritePropertiesList))
|
|
{
|
|
return FavoritePropertiesList.Contains(Path);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void FItemPropertyNode::SetDisplayNameOverride( const FText& InDisplayNameOverride )
|
|
{
|
|
DisplayNameOverride = InDisplayNameOverride;
|
|
}
|
|
|
|
FText FItemPropertyNode::GetDisplayName() const
|
|
{
|
|
FText FinalDisplayName;
|
|
|
|
if( !DisplayNameOverride.IsEmpty() )
|
|
{
|
|
FinalDisplayName = DisplayNameOverride;
|
|
}
|
|
else
|
|
{
|
|
const FProperty* PropertyPtr = GetProperty();
|
|
if( GetArrayIndex()==-1 && PropertyPtr != NULL )
|
|
{
|
|
// This item is not a member of an array, get a traditional display name
|
|
if ( FPropertySettings::Get().ShowFriendlyPropertyNames() )
|
|
{
|
|
//We are in "readable display name mode"../ Make a nice name
|
|
FinalDisplayName = PropertyPtr->GetDisplayNameText();
|
|
if ( FinalDisplayName.IsEmpty() )
|
|
{
|
|
FString PropertyDisplayName;
|
|
bool bIsBoolProperty = CastField<const FBoolProperty>(PropertyPtr) != NULL;
|
|
|
|
const TSharedPtr<FPropertyNode> ParentNode = ParentNodeWeakPtr.Pin();
|
|
const FStructProperty* ParentStructProperty = CastField<const FStructProperty>(ParentNode->GetProperty());
|
|
if( ParentStructProperty && ParentStructProperty->Struct->GetFName() == NAME_Rotator )
|
|
{
|
|
if( Property->GetFName() == "Roll" )
|
|
{
|
|
PropertyDisplayName = TEXT("X");
|
|
}
|
|
else if( Property->GetFName() == "Pitch" )
|
|
{
|
|
PropertyDisplayName = TEXT("Y");
|
|
}
|
|
else if( Property->GetFName() == "Yaw" )
|
|
{
|
|
PropertyDisplayName = TEXT("Z");
|
|
}
|
|
else
|
|
{
|
|
check(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PropertyDisplayName = Property->GetName();
|
|
}
|
|
if( GetDefault<UEditorStyleSettings>()->bShowFriendlyNames )
|
|
{
|
|
PropertyDisplayName = FName::NameToDisplayString( PropertyDisplayName, bIsBoolProperty );
|
|
}
|
|
|
|
FinalDisplayName = FText::FromString( PropertyDisplayName );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FinalDisplayName = FText::FromString( PropertyPtr->GetName() );
|
|
}
|
|
}
|
|
else if (const TSharedPtr<FPropertyNode> ParentNode = ParentNodeWeakPtr.Pin())
|
|
{
|
|
// Sets and maps do not have a display index.
|
|
FProperty* ParentProperty = ParentNode->GetProperty();
|
|
|
|
// Get the ArraySizeEnum class from meta data.
|
|
static const FName NAME_ArraySizeEnum("ArraySizeEnum");
|
|
UEnum* ArraySizeEnum = NULL;
|
|
if (PropertyPtr && PropertyPtr->HasMetaData(NAME_ArraySizeEnum))
|
|
{
|
|
ArraySizeEnum = FindObject<UEnum>(NULL, *Property->GetMetaData(NAME_ArraySizeEnum));
|
|
}
|
|
|
|
// Also handle UArray's having the ArraySizeEnum entry...
|
|
if (ArraySizeEnum == nullptr && CastField<FArrayProperty>(ParentProperty) != nullptr && ParentProperty->HasMetaData(NAME_ArraySizeEnum))
|
|
{
|
|
ArraySizeEnum = FindObject<UEnum>(NULL, *ParentProperty->GetMetaData(NAME_ArraySizeEnum));
|
|
}
|
|
|
|
if (CastField<FSetProperty>(ParentProperty) == nullptr && CastField<FMapProperty>(ParentProperty) == nullptr)
|
|
{
|
|
if (PropertyPtr != nullptr)
|
|
{
|
|
// Check if this property has Title Property Meta
|
|
static const FName NAME_TitleProperty = FName(TEXT("TitleProperty"));
|
|
FString TitleProperty = PropertyPtr->GetMetaData(NAME_TitleProperty);
|
|
if (!TitleProperty.IsEmpty())
|
|
{
|
|
FItemPropertyNode* NonConstThis = const_cast<FItemPropertyNode*>(this);
|
|
|
|
FReadAddressListData ReadAddress;
|
|
GetReadAddressUncached(*NonConstThis, ReadAddress);
|
|
|
|
const UStruct* PropertyStruct = nullptr;
|
|
|
|
if (const FObjectProperty* ObjectProperty = CastField<FObjectProperty>(PropertyPtr))
|
|
{
|
|
// We do this so we get the classes *exact* value and not just the base from PropertyClass
|
|
uint8* FoundAddress = ReadAddress.GetAddress(0);
|
|
UObject* ObjectValue = FoundAddress != nullptr ? ObjectProperty->GetObjectPropertyValue(FoundAddress) : nullptr;
|
|
|
|
if (ObjectValue != nullptr)
|
|
{
|
|
PropertyStruct = ObjectValue->GetClass();
|
|
}
|
|
}
|
|
|
|
// Find the property and get the right property handle
|
|
if (PropertyStruct != nullptr)
|
|
{
|
|
const TSharedPtr<IPropertyHandle> ThisAsHandle = PropertyEditorHelpers::GetPropertyHandle(NonConstThis->AsShared(), nullptr, nullptr);
|
|
TSharedPtr<FTitleMetadataFormatter> TitleFormatter = FTitleMetadataFormatter::TryParse(ThisAsHandle, TitleProperty);
|
|
if (TitleFormatter)
|
|
{
|
|
TitleFormatter->GetDisplayText(FinalDisplayName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(FinalDisplayName.IsEmpty())
|
|
{
|
|
// This item is a member of an array, its display name is its index
|
|
if (PropertyPtr == NULL || ArraySizeEnum == NULL)
|
|
{
|
|
if (ArraySizeEnum == nullptr)
|
|
{
|
|
FinalDisplayName = FText::AsNumber(GetArrayIndex());
|
|
}
|
|
else
|
|
{
|
|
FinalDisplayName = ArraySizeEnum->GetDisplayNameTextByIndex(GetArrayIndex());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FinalDisplayName = ArraySizeEnum->GetDisplayNameTextByIndex(GetArrayIndex());
|
|
}
|
|
}
|
|
}
|
|
// Maps should have display names that reflect the key and value types
|
|
else if (PropertyPtr != nullptr && CastField<FMapProperty>(ParentProperty) != nullptr)
|
|
{
|
|
FText FormatText = GetPropertyKeyNode().IsValid()
|
|
? LOCTEXT("MapValueDisplayFormat", "Value ({0})")
|
|
: LOCTEXT("MapKeyDisplayFormat", "Key ({0})");
|
|
|
|
FString TypeName;
|
|
|
|
if (const FStructProperty* StructProp = CastField<FStructProperty>(PropertyPtr))
|
|
{
|
|
// For struct props, use the name of the struct itself
|
|
TypeName = StructProp->Struct->GetName();
|
|
}
|
|
else if (const FEnumProperty* EnumProp = CastField<FEnumProperty>(PropertyPtr))
|
|
{
|
|
// For enum props, use the name of the enum
|
|
if (EnumProp->GetEnum() != nullptr)
|
|
{
|
|
TypeName = EnumProp->GetEnum()->GetName();
|
|
}
|
|
else
|
|
{
|
|
TypeName = TEXT("Enum");
|
|
}
|
|
}
|
|
else if(PropertyPtr->IsA<FStrProperty>())
|
|
{
|
|
// For strings, actually return "String" and not "Str"
|
|
TypeName = TEXT("String");
|
|
}
|
|
else
|
|
{
|
|
// For any other property, get the type from the property class
|
|
TypeName = PropertyPtr->GetClass()->GetName();
|
|
|
|
int32 EndIndex = TypeName.Find(TEXT("Property"), ESearchCase::IgnoreCase, ESearchDir::FromEnd);
|
|
|
|
if (EndIndex != -1)
|
|
{
|
|
TypeName.MidInline(0, EndIndex, EAllowShrinking::No);
|
|
}
|
|
}
|
|
|
|
if (FPropertySettings::Get().ShowFriendlyPropertyNames())
|
|
{
|
|
TypeName = FName::NameToDisplayString(TypeName, false);
|
|
}
|
|
|
|
FinalDisplayName = FText::Format(FormatText, FText::FromString(TypeName));
|
|
}
|
|
}
|
|
}
|
|
|
|
return FinalDisplayName;
|
|
}
|
|
|
|
void FItemPropertyNode::SetToolTipOverride( const FText& InToolTipOverride )
|
|
{
|
|
ToolTipOverride = InToolTipOverride;
|
|
}
|
|
|
|
FText FItemPropertyNode::GetToolTipText() const
|
|
{
|
|
if(!ToolTipOverride.IsEmpty())
|
|
{
|
|
return ToolTipOverride;
|
|
}
|
|
|
|
return PropertyEditorHelpers::GetToolTipText(GetProperty());
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|