void FAssetEditorManager::SaveOpenAssetEditors(bool bOnShutdown) { if(!bSavingOnShutdown) { TArray<FString> OpenAssets; // Don't save a list of assets to restore if we are running under a debugger if(!FPlatformMisc::IsDebuggerPresent()) { for (auto EditorPair : OpenedEditors) { IAssetEditorInstance* Editor = EditorPair.Key; if (Editor != NULL) { UObject* EditedObject = EditorPair.Value; if(EditedObject != NULL) { // only record assets that have a valid saved package UPackage* Package = EditedObject->GetOutermost(); if(Package != NULL && Package->GetFileSize() != 0) { OpenAssets.Add(EditedObject->GetPathName()); } } } } } GConfig->SetArray(TEXT("AssetEditorManager"), TEXT("OpenAssetsAtExit"), OpenAssets, GEditorPerProjectIni); GConfig->SetBool(TEXT("AssetEditorManager"), TEXT("CleanShutdown"), bOnShutdown, GEditorPerProjectIni); GConfig->Flush(false, GEditorPerProjectIni); } }
void ObjectHash::Clear() { bool any; do { any = false; unsigned skipped = 0; for ( OH_iterator itr = hash.begin(), itrend = hash.end(); itr != itrend; ) { UObject* obj = ( *itr ).second.get(); if ( obj->orphan() && obj->ref_counted_count() == 1 ) { hash.erase( itr++ ); any = true; } else { ++skipped; ++itr; } } } while ( any ); if ( !hash.empty() ) { INFO_PRINT << "Leftover objects in objecthash: " << hash.size() << "\n"; // the hash will be cleared after main() exits, with other statics. // this usually causes assertion failures and crashes. // creating a copy of the internal hash will ensure no refcounts reach zero. INFO_PRINT << "Leaking a copy of the objecthash in order to avoid a crash.\n"; new hs( hash ); } // hash.clear(); }
FText SGraphPinObject::GetObjectName() const { FText Value = FText::GetEmpty(); if (GraphPinObj != NULL) { UObject* DefaultObject = GraphPinObj->DefaultObject; if (DefaultObject != NULL) { Value = FText::FromString(DefaultObject->GetName()); int32 StringLen = Value.ToString().Len(); //If string is too long, then truncate (eg. "abcdefgijklmnopq" is converted as "abcd...nopq") const int32 MaxAllowedLength = 16; if (StringLen > MaxAllowedLength) { //Take first 4 characters FString TruncatedStr(Value.ToString().Left(4)); TruncatedStr += FString( TEXT("...")); //Take last 4 characters TruncatedStr += Value.ToString().Right(4); Value = FText::FromString(TruncatedStr); } } } return Value; }
void FContentComparisonHelper::RecursiveObjectCollection(UObject* InStartObject, int32 InCurrDepth, int32 InMaxDepth, TMap<UObject*,bool>& OutCollectedReferences) { // Serialize object with reference collector. TArray<UObject*> LocalCollectedReferences; FReferenceFinder ObjectReferenceCollector( LocalCollectedReferences, NULL, false, true, true, true ); ObjectReferenceCollector.FindReferences( InStartObject ); if (InCurrDepth < InMaxDepth) { InCurrDepth++; for (int32 ObjRefIdx = 0; ObjRefIdx < LocalCollectedReferences.Num(); ObjRefIdx++) { UObject* InnerObject = LocalCollectedReferences[ObjRefIdx]; if ((InnerObject != NULL) && (InnerObject->IsA(UFunction::StaticClass()) == false) && (InnerObject->IsA(UPackage::StaticClass()) == false) ) { OutCollectedReferences.Add(InnerObject, true); RecursiveObjectCollection(InnerObject, InCurrDepth, InMaxDepth, OutCollectedReferences); } } InCurrDepth--; } }
UEnum* GetEnumForByteTrack(TSharedPtr<ISequencer> Sequencer, const FGuid& OwnerObjectHandle, FName PropertyName, UMovieSceneByteTrack* ByteTrack) { UObject* RuntimeObject = Sequencer->GetFocusedMovieSceneSequence()->FindObject(OwnerObjectHandle); TSet<UEnum*> PropertyEnums; if (RuntimeObject != nullptr) { UProperty* Property = RuntimeObject->GetClass()->FindPropertyByName(PropertyName); if (Property != nullptr) { UByteProperty* ByteProperty = Cast<UByteProperty>(Property); if (ByteProperty != nullptr && ByteProperty->Enum != nullptr) { PropertyEnums.Add(ByteProperty->Enum); } } } UEnum* TrackEnum; if (PropertyEnums.Num() == 1) { TrackEnum = PropertyEnums.Array()[0]; } else { TrackEnum = nullptr; } return TrackEnum; }
// Finds the class for the given stack state. UStruct* FindClass( const FReadState& State ) { UStruct* Class = nullptr; if (State.Property != nullptr) { UProperty* ParentProperty = State.Property; UArrayProperty* ArrayProperty = Cast<UArrayProperty>(ParentProperty); if (ArrayProperty != nullptr) { ParentProperty = ArrayProperty->Inner; } UStructProperty* StructProperty = Cast<UStructProperty>(ParentProperty); UObjectPropertyBase* ObjectProperty = Cast<UObjectPropertyBase>(ParentProperty); if (StructProperty != nullptr) { Class = StructProperty->Struct; } else if (ObjectProperty != nullptr) { Class = ObjectProperty->PropertyClass; } } else { UObject* RootObject = static_cast<UObject*>(State.Data); Class = RootObject->GetClass(); } return Class; }
int32 UObjectLibrary::LoadAssetsFromPaths(const TArray<FString>& Paths) { int32 Count = 0; if (bIsFullyLoaded) { // We already ran this return 0; } bIsFullyLoaded = true; for (int PathIndex = 0; PathIndex < Paths.Num(); PathIndex++) { TArray<UObject*> LoadedObjects; FString Path = Paths[PathIndex]; if (EngineUtils::FindOrLoadAssetsByPath(Path, LoadedObjects, bHasBlueprintClasses ? EngineUtils::ATL_Class : EngineUtils::ATL_Regular)) { for (int32 i = 0; i < LoadedObjects.Num(); ++i) { UObject* Object = LoadedObjects[i]; if (Object == NULL || (ObjectBaseClass && !Object->IsA(ObjectBaseClass))) { // Incorrect type, skip continue; } AddObject(Object); Count++; } } } return Count; }
/** * Internal version of GetPathName() that eliminates unnecessary copies. */ void UObjectBaseUtility::GetPathName( const UObject* StopOuter, FString& ResultString ) const { if( this != StopOuter && this != NULL ) { UObject* Outer = GetOuter(); if ( Outer && Outer != StopOuter ) { Outer->GetPathName( StopOuter, ResultString ); // SUBOBJECT_DELIMITER is used to indicate that this object's outer is not a UPackage if (Outer->GetClass() != UPackage::StaticClass() && Outer->GetOuter()->GetClass() == UPackage::StaticClass()) { ResultString += SUBOBJECT_DELIMITER; } else { ResultString += TEXT("."); } } AppendName(ResultString); } else { ResultString += TEXT("None"); } }
FArchiveGenerateReferenceGraph::FArchiveGenerateReferenceGraph( FReferenceGraph& OutGraph ) : CurrentObject(NULL), ObjectGraph(OutGraph) { ArIsObjectReferenceCollector = true; ArIgnoreOuterRef = true; // Iterate over each object.. for( FObjectIterator It; It; ++It ) { UObject* Object = *It; // Skip transient and those about to be deleted if( !Object->HasAnyFlags( RF_Transient | RF_PendingKill ) ) { // only serialize non actors objects which have not been visited. // actors are skipped because we have don't need them to show the reference tree // @todo, may need to serialize them later for full reference graph. if( !VisitedObjects.Find( Object ) && !Object->IsA( AActor::StaticClass() ) ) { // Set the current object to the one we are about to serialize CurrentObject = Object; // This object has been visited. Any serializations after this should skip this object VisitedObjects.Add( Object ); Object->Serialize( *this ); } } } }
int32 UFixupNeedsLoadForEditorGameCommandlet::InitializeResaveParameters(const TArray<FString>& Tokens, TArray<FString>& MapPathNames) { int32 Result = Super::InitializeResaveParameters(Tokens, MapPathNames); // We need ResaveClasses to be specified, otherwise we won't know what to update if (Result == 0 && !ResaveClasses.Num()) { UE_LOG(LogContentCommandlet, Error, TEXT("FixupNeedsLoadForEditorGame commandlet requires at least one resave class name. Use -RESAVECLASS=ClassA,ClassB,ClassC to specify resave classes.")); Result = 1; } else { for (FName& ClassName : ResaveClasses) { if (!ResaveClassNeedsLoadForEditorGameValues.Contains(ClassName)) { UClass* ResaveClass = FindObject<UClass>(ANY_PACKAGE, *ClassName.ToString()); if (ResaveClass) { UObject* DefaultObject = ResaveClass->GetDefaultObject(); ResaveClassNeedsLoadForEditorGameValues.Add(ClassName, DefaultObject->NeedsLoadForEditorGame()); } } else if (Verbosity != UResavePackagesCommandlet::ONLY_ERRORS) { UE_LOG(LogContentCommandlet, Warning, TEXT("Resave Class \"%s\" could not be found. Make sure the class name is valid and that it's a native class."), *ClassName.ToString()); } } if (ResaveClassNeedsLoadForEditorGameValues.Num() == 0) { UE_LOG(LogContentCommandlet, Error, TEXT("Got %d classes to resave but none of the exist."), ResaveClasses.Num()); Result = 1; } } return Result; }
void FObjectReplicator::PostReceivedBunch() { if ( GetObject() == NULL ) { UE_LOG(LogNet, Verbose, TEXT("PostReceivedBunch: Object == NULL")); return; } // Call PostNetReceive const bool bIsServer = (OwningChannel->Connection->Driver->ServerConnection == NULL); if (!bIsServer && bHasReplicatedProperties) { PostNetReceive(); bHasReplicatedProperties = false; } // Check if PostNetReceive() destroyed Object UObject *Object = GetObject(); if (Object == NULL || Object->IsPendingKill()) { return; } // Call RepNotifies CallRepNotifies(true); }
void UK2Node_MacroInstance::PostPasteNode() { const UBlueprint* InstanceOwner = GetBlueprint(); // Find the owner of the macro graph const UEdGraph* MacroGraph = MacroGraphReference.GetGraph(); UObject* MacroOwner = MacroGraph->GetOuter(); UBlueprint* MacroOwnerBP = NULL; while(MacroOwner) { MacroOwnerBP = Cast<UBlueprint>(MacroOwner); if(MacroOwnerBP) { break; } MacroOwner = MacroOwner->GetOuter(); } if((MacroOwnerBP != NULL) && (MacroOwnerBP->BlueprintType != BPTYPE_MacroLibrary) && (MacroOwnerBP != InstanceOwner)) { // If this is a graph from another blueprint that is NOT a library, disallow the connection! MacroGraphReference.SetGraph(NULL); } Super::PostPasteNode(); }
// Looks at the Objects array and returns the best base class. Called by // Finalize(); that is, when the list of selected objects is being finalized. void FObjectPropertyNode::SetBestBaseClass() { BaseClass = NULL; for( int32 x = 0 ; x < Objects.Num() ; ++x ) { UObject* Obj = Objects[x].Get(); if( Obj ) { UClass* ObjClass = Cast<UClass>(Obj); if (ObjClass == NULL) { ObjClass = Obj->GetClass(); } check( ObjClass ); // Initialize with the class of the first object we encounter. if( BaseClass == NULL ) { BaseClass = ObjClass; } // If we've encountered an object that's not a subclass of the current best baseclass, // climb up a step in the class hierarchy. while( !ObjClass->IsChildOf( BaseClass.Get() ) ) { BaseClass = BaseClass->GetSuperClass(); } } } }
int32 FObjectMemoryAnalyzer::GetResults(TArray<FObjectMemoryUsage>& Results) { if (BaseClass != NULL) { uint32 ExclusionFlags = (AnalyzeFlags&EAnalyzeFlags::IncludeDefaultObjects)==0 ? (RF_ClassDefaultObject|RF_ArchetypeObject) : 0; for( FObjectIterator It(BaseClass, false, (EObjectFlags)ExclusionFlags); It; ++It ) { UObject* Object = *It; if (!(AnalyzeFlags&EAnalyzeFlags::IncludeDefaultObjects) && Object->IsDefaultSubobject()) { continue; }; FObjectMemoryUsage& Annotation = MemUsageAnnotations.GetAnnotationRef(Object); if (Annotation.IsRoot()) { Annotation.Object = Object; Results.Add(Annotation); } } } if (ObjectList.Num() > 0) { for (int32 i=0; i < ObjectList.Num(); ++i) { FObjectMemoryUsage& Annotation = MemUsageAnnotations.GetAnnotationRef(ObjectList[i]); check(Annotation.IsRoot()); Annotation.Object = ObjectList[i]; Results.Add(Annotation); } } return Results.Num(); }
TSharedPtr<FGraphNodeClassNode> FGraphNodeClassHelper::CreateClassDataNode(const class FAssetData& AssetData) { TSharedPtr<FGraphNodeClassNode> Node; const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass"); const FString* ParentClassname = AssetData.TagsAndValues.Find("ParentClass"); if (GeneratedClassname && ParentClassname) { FString AssetClassName = *GeneratedClassname; UObject* Outer1(NULL); ResolveName(Outer1, AssetClassName, false, false); FString AssetParentClassName = *ParentClassname; UObject* Outer2(NULL); ResolveName(Outer2, AssetParentClassName, false, false); Node = MakeShareable(new FGraphNodeClassNode); Node->ParentClassName = AssetParentClassName; UObject* AssetOb = AssetData.IsAssetLoaded() ? AssetData.GetAsset() : NULL; UBlueprint* AssetBP = Cast<UBlueprint>(AssetOb); UClass* AssetClass = AssetBP ? *AssetBP->GeneratedClass : AssetOb ? AssetOb->GetClass() : NULL; FGraphNodeClassData NewData(AssetData.AssetName.ToString(), AssetData.PackageName.ToString(), AssetClassName, AssetClass); Node->Data = NewData; } return Node; }
void TargetCursor::handle_target_cursor( Mobile::Character* chr, PKTBI_6C* msg ) { if ( msg->selected_serial != 0 ) // targetted something { if ( chr->dead() ) // but is dead { if ( chr->client != NULL ) send_sysmessage( chr->client, "I am dead and cannot do that." ); cancel( chr ); return; } if ( ( chr->frozen() || chr->paralyzed() ) && !chr->setting_enabled( "freemove" ) ) { if ( chr->client != NULL ) { if ( chr->frozen() ) private_say_above( chr, chr, "I am frozen and cannot do that." ); else if ( chr->paralyzed() ) private_say_above( chr, chr, "I am paralyzed and cannot do that." ); } cancel( chr ); return; } u32 selected_serial = cfBEu32( msg->selected_serial ); UObject* obj = system_find_object( selected_serial ); if ( obj != NULL && obj->script_isa( POLCLASS_MOBILE ) && !obj->script_isa( POLCLASS_NPC ) ) { Mobile::Character* targeted = find_character( selected_serial ); // check for when char is not logged on if ( targeted != NULL ) { if ( !chr->is_visible_to_me( targeted ) ) { cancel( chr ); return; } if ( msg->cursor_type == 1 ) { if ( ( JusticeRegion::RunNoCombatCheck( chr->client ) == true ) || ( JusticeRegion::RunNoCombatCheck( targeted->client ) == true ) ) { send_sysmessage( chr->client, "Combat is not allowed in this area." ); cancel( chr ); return; } } } } } if ( msg->x != 0xffff || msg->selected_serial != 0 ) on_target_cursor( chr, msg ); else cancel( chr ); }
Multi::UMulti* system_find_multi( u32 serial ) { UObject* obj = objecthash.Find( serial ); if ( obj != NULL && obj->ismulti() && !obj->orphan() ) return static_cast<Multi::UMulti*>( obj ); else return NULL; }
Mobile::Character* system_find_mobile( u32 serial /*, int sysfind_flags*/ ) { UObject* obj = objecthash.Find( serial ); if ( obj != NULL && obj->ismobile() && !obj->orphan() ) return static_cast<Mobile::Character*>( obj ); else return NULL; }
UObject* system_find_object( u32 serial ) { UObject* obj = objecthash.Find( serial ); if ( obj != NULL && !obj->orphan() ) return obj; else return NULL; }
Items::Item *system_find_item( u32 serial/*, int sysfind_flags */ ) { UObject* obj = objecthash.Find( serial ); if ( obj != NULL && obj->isitem() && !obj->orphan() ) return static_cast<Items::Item*>( obj ); else return NULL; }
FText FSimpleAssetEditor::GetToolkitName() const { const auto EditingObjects = GetEditingObjects(); check( EditingObjects.Num() > 0 ); FFormatNamedArguments Args; Args.Add( TEXT("ToolkitName"), GetBaseToolkitName() ); if( EditingObjects.Num() == 1 ) { const UObject* EditingObject = EditingObjects[ 0 ]; const bool bDirtyState = EditingObject->GetOutermost()->IsDirty(); Args.Add( TEXT("ObjectName"), FText::FromString( EditingObject->GetName() ) ); Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() ); return FText::Format( LOCTEXT("ToolkitTitle", "{ObjectName}{DirtyState} - {ToolkitName}"), Args ); } else { bool bDirtyState = false; UClass* SharedBaseClass = NULL; for( int32 x = 0; x < EditingObjects.Num(); ++x ) { UObject* Obj = EditingObjects[ x ]; check( Obj ); UClass* ObjClass = Cast<UClass>(Obj); if (ObjClass == NULL) { ObjClass = Obj->GetClass(); } check( ObjClass ); // Initialize with the class of the first object we encounter. if( SharedBaseClass == NULL ) { SharedBaseClass = ObjClass; } // If we've encountered an object that's not a subclass of the current best baseclass, // climb up a step in the class hierarchy. while( !ObjClass->IsChildOf( SharedBaseClass ) ) { SharedBaseClass = SharedBaseClass->GetSuperClass(); } // If any of the objects are dirty, flag the label bDirtyState |= Obj->GetOutermost()->IsDirty(); } Args.Add( TEXT("NumberOfObjects"), EditingObjects.Num() ); Args.Add( TEXT("ClassName"), FText::FromString( SharedBaseClass->GetName() ) ); Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() ); return FText::Format( LOCTEXT("ToolkitTitle_EditingMultiple", "{NumberOfObjects} {ClassName}{DirtyState} - {ToolkitName}"), Args ); } }
void USelection::DeselectAll( UClass* InClass ) { // Fast path for deselecting all UObjects with any flags if ( InClass == UObject::StaticClass() ) { InClass = nullptr; } bool bSelectionChanged = false; TSet<FSelectedClassInfo> RemovedClasses; // Remove from the end to minimize memmoves. for ( int32 i = SelectedObjects.Num()-1 ; i >= 0 ; --i ) { UObject* Object = GetSelectedObject(i); if ( !Object ) { // Remove NULLs from SelectedObjects array. SelectedObjects.RemoveAt( i ); } else if( !InClass || Object->IsA( InClass ) ) { // if the object is of type InClass then all objects of that same type will be removed RemovedClasses.Add(FSelectedClassInfo(Object->GetClass())); GSelectedAnnotation.Clear(Object); SelectedObjects.RemoveAt( i ); // Call this after the item has been removed from the selection set. USelection::SelectObjectEvent.Broadcast( Object ); bSelectionChanged = true; } } if( InClass == nullptr ) { SelectedClasses.Empty(); } else { // Remove the passed in class and all child classes that were removed // from the list of currently selected classes RemovedClasses.Add(InClass); SelectedClasses = SelectedClasses.Difference(RemovedClasses); } if ( bSelectionChanged ) { MarkBatchDirty(); if ( !IsBatchSelecting() ) { USelection::SelectionChangedEvent.Broadcast(this); } } }
UObject* FBlueprintNativeCodeGenModule::FindReplacedNameAndOuter(UObject* Object, FName& OutName) const { OutName = NAME_None; UObject* Outer = nullptr; UActorComponent* ActorComponent = Cast<UActorComponent>(Object); if (ActorComponent) { //if is child of a BPGC and not child of a CDO UBlueprintGeneratedClass* BPGC = nullptr; for (UObject* OuterObject = ActorComponent->GetOuter(); OuterObject && !BPGC; OuterObject = OuterObject->GetOuter()) { if (OuterObject->HasAnyFlags(RF_ClassDefaultObject)) { return Outer; } BPGC = Cast<UBlueprintGeneratedClass>(OuterObject); } for (UBlueprintGeneratedClass* SuperBPGC = BPGC; SuperBPGC && (OutName == NAME_None); SuperBPGC = Cast<UBlueprintGeneratedClass>(SuperBPGC->GetSuperClass())) { if (SuperBPGC->InheritableComponentHandler) { FComponentKey FoundKey = SuperBPGC->InheritableComponentHandler->FindKey(ActorComponent); if (FoundKey.IsValid()) { OutName = FoundKey.IsSCSKey() ? FoundKey.GetSCSVariableName() : ActorComponent->GetFName(); Outer = BPGC->GetDefaultObject(false); break; } } if (SuperBPGC->SimpleConstructionScript) { for (auto Node : SuperBPGC->SimpleConstructionScript->GetAllNodes()) { if (Node->ComponentTemplate == ActorComponent) { OutName = Node->VariableName; if (OutName != NAME_None) { Outer = BPGC->GetDefaultObject(false); break; } } } } } } if (Outer && (EReplacementResult::ReplaceCompletely == IsTargetedForReplacement(Object->GetClass()))) { UE_LOG(LogBlueprintCodeGen, Log, TEXT("Object '%s' has replaced name '%s' and outer: '%s'"), *GetPathNameSafe(Object), *OutName.ToString(), *GetPathNameSafe(Outer)); return Outer; } return nullptr; }
void UPackageMap::LogDebugInfo(FOutputDevice& Ar) { for (auto It = Cache->ObjectLookup.CreateIterator(); It; ++It) { FNetworkGUID NetGUID = It.Key(); UObject *Obj = It.Value().Object.Get(); UE_LOG(LogCoreNet, Log, TEXT("%s - %s"), *NetGUID.ToString(), Obj ? *Obj->GetPathName() : TEXT("NULL")); } }
/** * Enacts the transaction. */ void FTransaction::Apply() { checkSlow(Inc==1||Inc==-1); // Figure out direction. const int32 Start = Inc==1 ? 0 : Records.Num()-1; const int32 End = Inc==1 ? Records.Num() : -1; // Init objects. TArray<UObject*> ChangedObjects; for( int32 i=Start; i!=End; i+=Inc ) { Records[i].bRestored = false; if(ChangedObjects.Find(Records[i].Object) == INDEX_NONE) { Records[i].Object->CheckDefaultSubobjects(); Records[i].Object->PreEditUndo(); ChangedObjects.Add(Records[i].Object); } } for( int32 i=Start; i!=End; i+=Inc ) { Records[i].Restore( this ); } NumModelsModified = 0; // Count the number of UModels that were changed. for(int32 ObjectIndex = 0;ObjectIndex < ChangedObjects.Num();ObjectIndex++) { UObject* ChangedObject = ChangedObjects[ObjectIndex]; UModel* Model = Cast<UModel>(ChangedObject); if( Model && Model->Nodes.Num() ) { FBSPOps::bspBuildBounds( Model ); ++NumModelsModified; } ChangedObject->PostEditUndo(); } // Rebuild BSP here instead of waiting for the next tick since // multiple transaction events can occur in a single tick if (ABrush::NeedsRebuild()) { GEditor->RebuildAlteredBSP(); } // Flip it. if( bFlip ) { Inc *= -1; } for(int32 ObjectIndex = 0;ObjectIndex < ChangedObjects.Num();ObjectIndex++) { UObject* ChangedObject = ChangedObjects[ObjectIndex]; ChangedObject->CheckDefaultSubobjects(); } }
size_t UPKReader::GetScriptRelOffset(uint32_t idx) { UObject* Obj = GetExportObject(idx, false, true); if (Obj->IsStructure() == false) { LogWarn("Object has no script in GetScriptSize!"); return 0; } return Obj->GetScriptOffset(); }
bool UFbxSkeletalMeshImportData::CanEditChange(const UProperty* InProperty) const { bool bMutable = Super::CanEditChange(InProperty); UObject* Outer = GetOuter(); if(Outer && bMutable) { // Let the FbxImportUi object handle the editability of our properties bMutable = Outer->CanEditChange(InProperty); } return bMutable; }
const FSlateBrush* SPropertyEditorEditInline::GetDisplayValueIcon() const { UObject* CurrentValue = nullptr; FPropertyAccess::Result Result = PropertyEditor->GetPropertyHandle()->GetValue( CurrentValue ); if( Result == FPropertyAccess::Success && CurrentValue != nullptr ) { return FClassIconFinder::FindIconForClass(CurrentValue->GetClass()); } return nullptr; }
/** * Traverses the outer chain searching for the next object of a certain type. (T must be derived from UObject) * * @param Target class to search for * @return a pointer to the first object in this object's Outer chain which is of the correct type. */ UObject* UObjectBaseUtility::GetTypedOuter(UClass* Target) const { UObject* Result = NULL; for ( UObject* NextOuter = GetOuter(); Result == NULL && NextOuter != NULL; NextOuter = NextOuter->GetOuter() ) { if ( NextOuter->IsA(Target) ) { Result = NextOuter; } } return Result; }
FString FEmitDefaultValueHelper::HandleSpecialTypes(FEmitterLocalContext& Context, const UProperty* Property, const uint8* ValuePtr) { //TODO: Use Path maps for Objects if (auto ObjectProperty = Cast<UObjectProperty>(Property)) { UObject* Object = ObjectProperty->GetPropertyValue(ValuePtr); if (Object) { { UClass* ObjectClassToUse = Context.GetFirstNativeOrConvertedClass(ObjectProperty->PropertyClass); const FString MappedObject = Context.FindGloballyMappedObject(Object, ObjectClassToUse); if (!MappedObject.IsEmpty()) { return MappedObject; } } const bool bCreatingSubObjectsOfClass = (Context.CurrentCodeType == FEmitterLocalContext::EGeneratedCodeType::SubobjectsOfClass); { auto BPGC = Context.GetCurrentlyGeneratedClass(); auto CDO = BPGC ? BPGC->GetDefaultObject(false) : nullptr; if (BPGC && Object && CDO && Object->IsIn(BPGC) && !Object->IsIn(CDO) && bCreatingSubObjectsOfClass) { return HandleClassSubobject(Context, Object, FEmitterLocalContext::EClassSubobjectList::MiscConvertedSubobjects, true, true); } } if (!bCreatingSubObjectsOfClass && Property->HasAnyPropertyFlags(CPF_InstancedReference)) { const FString CreateAsInstancedSubobject = HandleInstancedSubobject(Context, Object, Object->HasAnyFlags(RF_ArchetypeObject)); if (!CreateAsInstancedSubobject.IsEmpty()) { return CreateAsInstancedSubobject; } } } else if (ObjectProperty->HasMetaData(FBlueprintMetadata::MD_LatentCallbackTarget)) { return TEXT("this"); } } if (auto StructProperty = Cast<UStructProperty>(Property)) { FString StructConstructor; if (SpecialStructureConstructor(StructProperty->Struct, ValuePtr, &StructConstructor)) { return StructConstructor; } } return FString(); }