void UEnvQueryGenerator_OnCircle::PostEditChangeProperty( struct FPropertyChangedEvent& PropertyChangedEvent) { static const FName NAME_Angle = GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, Angle); static const FName NAME_Radius = GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, Radius); if (PropertyChangedEvent.Property != NULL) { const FName PropName = PropertyChangedEvent.MemberProperty->GetFName(); if (PropName == NAME_Angle) { Angle.Value = FMath::Clamp(Angle.Value, 0.0f, 360.f); AngleRadians = FMath::DegreesToRadians(Angle.Value); bDefineArc = Angle.Value < 360.f && Angle.Value > 0.f; } else if (PropName == NAME_Radius) { if (Radius.Value <= 0.f) { Radius.Value = 100.f; } } ItemSpacing.Value = FMath::Max(1.0f, ItemSpacing.Value); } Super::PostEditChangeProperty(PropertyChangedEvent); }
void AFlySkillActor::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) { FName PropertyName = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : NAME_None; if ((PropertyName == GET_MEMBER_NAME_CHECKED(AFlySkillActor, UseTargetLocation))) { if (UseTargetLocation) { UseTargetActor = false; } else { UseTargetActor = true; } } else if ((PropertyName == GET_MEMBER_NAME_CHECKED(AFlySkillActor, UseTargetActor))) { if (UseTargetActor) { UseTargetLocation = false; } else { UseTargetLocation = true; } } Super::PostEditChangeProperty(PropertyChangedEvent); }
void FCinematicOptionsCustomization::CustomizeChildren(TSharedRef<class IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& ChildBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils) { bPlayMatinee = StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bPlayMatinee)); bLoop = StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bLoop)); Matinee = StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, Matinee)); ChildBuilder.AddChildProperty(StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bPlayMatinee)).ToSharedRef()); ChildBuilder.AddChildProperty(StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bLoop)).ToSharedRef()); ChildBuilder.AddChildContent(LOCTEXT("Matinee", "Matinee")) .NameContent() [ Matinee->CreatePropertyNameWidget() ] .ValueContent() .HAlign(HAlign_Fill) [ SNew(SHorizontalBox) + SHorizontalBox::Slot() .MaxWidth(109.0f) [ SNew(SComboButton) .OnGetMenuContent(this, &FCinematicOptionsCustomization::OnGetMatineeList) .ContentPadding(FMargin(2.0f, 2.0f)) .ButtonContent() [ SNew(STextBlock) .Text(this, &FCinematicOptionsCustomization::GetCurrentMatineeName) .Font(IDetailLayoutBuilder::GetDetailFont()) ] ] ]; }
void FFoliageTypePaintingCustomization::CustomizeDetails(IDetailLayoutBuilder& DetailLayoutBuilder) { // Hide categories we are not going to customize FFoliageTypeCustomizationHelpers::HideFoliageCategory(DetailLayoutBuilder, "Procedural"); FFoliageTypeCustomizationHelpers::HideFoliageCategory(DetailLayoutBuilder, "Reapply"); // Show all the properties with a reapply condition or that depend on another variable to be relevant TMap<const FName, IDetailPropertyRow*> PropertyRowsByName; ShowFoliagePropertiesForCategory(DetailLayoutBuilder, "Painting", PropertyRowsByName); ShowFoliagePropertiesForCategory(DetailLayoutBuilder, "Placement", PropertyRowsByName); ShowFoliagePropertiesForCategory(DetailLayoutBuilder, "InstanceSettings", PropertyRowsByName); // Density adjustment factor should only be visible when reapplying FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, DensityAdjustmentFactor)), TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetReapplyModeVisibility)), TAttribute<bool>()); // Set the scale visibility attribute for each axis Scaling = DetailLayoutBuilder.GetProperty(GET_MEMBER_NAME_CHECKED(UFoliageType, Scaling)); ReapplyScaling = DetailLayoutBuilder.GetProperty(GET_MEMBER_NAME_CHECKED(UFoliageType, ReapplyScaling)); FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, ScaleX)), TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetScaleVisibility, EAxis::X)), TAttribute<bool>()); FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, ScaleY)), TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetScaleVisibility, EAxis::Y)), TAttribute<bool>()); FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, ScaleZ)), TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetScaleVisibility, EAxis::Z)), TAttribute<bool>()); }
void UEnvQueryGenerator_OnCircle::PostEditChangeProperty( FPropertyChangedEvent& PropertyChangedEvent) { if (PropertyChangedEvent.Property != NULL) { const FName PropName = PropertyChangedEvent.MemberProperty->GetFName(); if (PropName == GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, ArcAngle)) { ArcAngle.DefaultValue = FMath::Clamp(ArcAngle.DefaultValue, 0.0f, 360.f); AngleRadians = FMath::DegreesToRadians(ArcAngle.DefaultValue); bDefineArc = (ArcAngle.DefaultValue < 360.f) && (ArcAngle.DefaultValue > 0.f); } else if (PropName == GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, CircleRadius)) { if (CircleRadius.DefaultValue <= 0.f) { CircleRadius.DefaultValue = 100.f; } } else if (PropName == GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, SpaceBetween)) { SpaceBetween.DefaultValue = FMath::Max(1.0f, SpaceBetween.DefaultValue); } } Super::PostEditChangeProperty(PropertyChangedEvent); }
void FTileLODEntryDetailsCustomization::CustomizeChildren(TSharedRef<IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& ChildBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils ) { LODIndexHandle = StructPropertyHandle->GetChildHandle( GET_MEMBER_NAME_CHECKED(FTileLODEntryDetails, LODIndex) ); TSharedPtr<IPropertyHandle> DistanceProperty = StructPropertyHandle->GetChildHandle( GET_MEMBER_NAME_CHECKED(FTileLODEntryDetails, Distance) ); TSharedPtr<IPropertyHandle> SimplificationDetails = StructPropertyHandle->GetChildHandle( GET_MEMBER_NAME_CHECKED(FTileLODEntryDetails, SimplificationDetails) ); ChildBuilder.AddChildProperty(LODIndexHandle.ToSharedRef()) .Visibility(EVisibility::Hidden); ChildBuilder.AddChildProperty(DistanceProperty.ToSharedRef()) .IsEnabled(TAttribute<bool>::Create(TAttribute<bool>::FGetter::CreateSP(this, &FTileLODEntryDetailsCustomization::IsLODDistanceEnabled))); ChildBuilder.AddChildProperty(SimplificationDetails.ToSharedRef()) .IsEnabled(TAttribute<bool>::Create(TAttribute<bool>::FGetter::CreateSP(this, &FTileLODEntryDetailsCustomization::IsGenerateTileEnabled))); }
void FDerivedCustomization::CustomizeDetails(IDetailLayoutBuilder& DetailLayout) { // So now we're customizing UDerivedClass object // First, try to hide an inherited property { // 'HideMe' property is defined in UBaseClass TSharedPtr<IPropertyHandle> PropertyToHide = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UDerivedClass, HideMe)); PropertyToHide->MarkHiddenByCustomization(); } { // Now grab any struct property (or property that has customized property value widget) // Note that this is property defined in UDerivedClass! TSharedPtr<IPropertyHandle> TestProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UDerivedClass, Vector2dProperty)); // Hide this property TestProperty->MarkHiddenByCustomization(); // Get a category so we can add a TestProperty back to the panel IDetailCategoryBuilder& DerivedCategory = DetailLayout.EditCategory("Derived"); DerivedCategory.AddCustomRow(LOCTEXT("DerivedObjectLabel", "Derived")) .NameContent() [ TestProperty->CreatePropertyNameWidget() ] .ValueContent() [ // This will return NullWidget - thats the problem TestProperty->CreatePropertyValueWidget() ]; } }
void UIOSRuntimeSettings::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) { Super::PostEditChangeProperty(PropertyChangedEvent); // Ensure that at least one orientation is supported if (!bSupportsPortraitOrientation && !bSupportsUpsideDownOrientation && !bSupportsLandscapeLeftOrientation && !bSupportsLandscapeRightOrientation) { bSupportsPortraitOrientation = true; UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bSupportsPortraitOrientation)), GetDefaultConfigFilename()); } // Ensure that at least one API is supported if (!bSupportsMetal && !bSupportsOpenGLES2 && !bSupportsMetalMRT) { bSupportsOpenGLES2 = true; UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bSupportsOpenGLES2)), GetDefaultConfigFilename()); } // Ensure that at least armv7 is selected for shipping and dev if (!bDevForArmV7 && !bDevForArm64 && !bDevForArmV7S) { bDevForArmV7 = true; UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bDevForArmV7)), GetDefaultConfigFilename()); } if (!bShipForArmV7 && !bShipForArm64 && !bShipForArmV7S) { bShipForArmV7 = true; UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bShipForArmV7)), GetDefaultConfigFilename()); } }
void FAxisMappingsNodeBuilder::OnAxisMappingNameCommitted(const FText& InName, ETextCommit::Type CommitInfo, const FMappingSet MappingSet) { const FScopedTransaction Transaction(LOCTEXT("RenameAxisMapping_Transaction", "Rename Axis Mapping")); FName NewName = FName(*InName.ToString()); FName CurrentName = NewName; if (MappingSet.Mappings.Num() > 0) { MappingSet.Mappings[0]->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->GetValue(CurrentName); } if (NewName != CurrentName) { for (int32 Index = 0; Index < MappingSet.Mappings.Num(); ++Index) { MappingSet.Mappings[Index]->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->SetValue(NewName); } if (MappingSet.DetailGroup) { RenamedGroupExpansionState.Key = NewName; RenamedGroupExpansionState.Value = MappingSet.DetailGroup->GetExpansionState(); // Don't want to save expansion state of old name MappingSet.DetailGroup->ToggleExpansion(false); } } }
void FCameraLensSettingsCustomization::CustomizeChildren(TSharedRef<IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& ChildBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils) { // Retrieve structure's child properties uint32 NumChildren; StructPropertyHandle->GetNumChildren(NumChildren); TMap<FName, TSharedPtr< IPropertyHandle > > PropertyHandles; for (uint32 ChildIndex = 0; ChildIndex < NumChildren; ++ChildIndex) { TSharedRef<IPropertyHandle> ChildHandle = StructPropertyHandle->GetChildHandle(ChildIndex).ToSharedRef(); const FName PropertyName = ChildHandle->GetProperty()->GetFName(); PropertyHandles.Add(PropertyName, ChildHandle); } // Retrieve special case properties MinFocalLengthHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinFocalLength)); MaxFocalLengthHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MaxFocalLength)); MinFStopHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinFStop)); MaxFStopHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MaxFStop)); MinFocusDistanceHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinimumFocusDistance)); for (auto Iter(PropertyHandles.CreateConstIterator()); Iter; ++Iter) { if (Iter.Value() == MinFocusDistanceHandle) { // skip showing these in the panel for now, as we don't really use them continue; } IDetailPropertyRow& SettingsRow = ChildBuilder.AddChildProperty(Iter.Value().ToSharedRef()); } }
void UGameMapsSettings::PostReloadConfig( UProperty* PropertyThatWasLoaded ) { if (PropertyThatWasLoaded) { if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, EditorStartupMap)) { FixMapAssetRef(EditorStartupMap); } else if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, GameDefaultMap)) { FixMapAssetRef(GameDefaultMap); } else if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, ServerDefaultMap)) { FixMapAssetRef(ServerDefaultMap); } else if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, TransitionMap)) { FixMapAssetRef(TransitionMap); } } else { FixMapAssetRef(EditorStartupMap); FixMapAssetRef(GameDefaultMap); FixMapAssetRef(ServerDefaultMap); FixMapAssetRef(TransitionMap); } }
void AAudioVolume::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) { Super::PostEditChangeProperty(PropertyChangedEvent); Settings.Volume = FMath::Clamp<float>( Settings.Volume, 0.0f, 1.0f ); AmbientZoneSettings.InteriorTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.InteriorTime ); AmbientZoneSettings.InteriorLPFTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.InteriorLPFTime ); AmbientZoneSettings.ExteriorTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.ExteriorTime ); AmbientZoneSettings.ExteriorLPFTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.ExteriorLPFTime ); if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(AAudioVolume, Priority)) { GetWorld()->AudioVolumes.Sort([](const AAudioVolume& A, const AAudioVolume& B) { return (A.GetPriority() > B.GetPriority()); }); } if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(AAudioVolume, bEnabled)) { if (bEnabled) { AddProxy(); } else { RemoveProxy(); } } else if (bEnabled) { UpdateProxy(); } }
void ADynamicWeather::PostEditChangeProperty(FPropertyChangedEvent &Event) { Super::PostEditChangeProperty(Event); const FName PropertyName = (Event.Property != NULL ? Event.Property->GetFName() : NAME_None); if (PropertyName == GET_MEMBER_NAME_CHECKED(ADynamicWeather, Weather)) { Update(); } else if ((PropertyName == GET_MEMBER_NAME_CHECKED(ADynamicWeather, bSaveToConfigFile)) || (PropertyName == GET_MEMBER_NAME_CHECKED(ADynamicWeather, bLoadFromConfigFile))) { // Do nothing. } else { AdjustSunPositionBasedOnActorRotation(); } if (bSaveToConfigFile) { bSaveToConfigFile = false; if (SaveToConfigFile()) { UE_LOG(LogCarla, Log, TEXT("Weather \"%s\" saved to config file"), *Weather.Name); } else { UE_LOG(LogCarla, Error, TEXT("Error saving weather to config file")); } } if (bLoadFromConfigFile) { bLoadFromConfigFile = false; if (LoadFromConfigFile()) { UE_LOG(LogCarla, Log, TEXT("Weather \"%s\" loaded from config file"), *Weather.Name); Update(); } else { UE_LOG(LogCarla, Error, TEXT("Error loading weather from config file")); } } }
void USplineComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) { if (PropertyChangedEvent.Property != nullptr) { const FName PropertyName(PropertyChangedEvent.Property->GetFName()); if (PropertyName == GET_MEMBER_NAME_CHECKED(USplineComponent, ReparamStepsPerSegment) || PropertyName == GET_MEMBER_NAME_CHECKED(USplineComponent, bStationaryEndpoints)) { UpdateSpline(); } if (PropertyName == GET_MEMBER_NAME_CHECKED(USplineComponent, bClosedLoop)) { if (bClosedLoop) { // Spline is guaranteed to be non-looping when we get here (due to PreEditChange). // Now just force the loop endpoint to be added if bClosedLoop == true. AddLoopEndpoint(); } UpdateSpline(); } } Super::PostEditChangeProperty(PropertyChangedEvent); }
void FSpriteDetailsCustomization::BuildTextureSection(IDetailCategoryBuilder& SpriteCategory, IDetailLayoutBuilder& DetailLayout) { // Grab information about the material TSharedPtr<IPropertyHandle> DefaultMaterialProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, DefaultMaterial)); FText SourceTextureOverrideLabel; if (DefaultMaterialProperty.IsValid()) { UObject* DefaultMaterialAsObject; if (DefaultMaterialProperty->GetValue(/*out*/ DefaultMaterialAsObject) == FPropertyAccess::Success) { if (UMaterialInterface* DefaultMaterialInterface = Cast<UMaterialInterface>(DefaultMaterialAsObject)) { if (UMaterial* DefaultMaterial = DefaultMaterialInterface->GetMaterial()) { // Get a list of sprite samplers TArray<const UMaterialExpressionSpriteTextureSampler*> SpriteSamplerExpressions; DefaultMaterial->GetAllExpressionsOfType(/*inout*/ SpriteSamplerExpressions); // Turn that into a set of labels for (const UMaterialExpressionSpriteTextureSampler* Sampler : SpriteSamplerExpressions) { if (!Sampler->SlotDisplayName.IsEmpty()) { if (Sampler->bSampleAdditionalTextures) { AdditionalTextureLabels.FindOrAdd(Sampler->AdditionalSlotIndex) = Sampler->SlotDisplayName; } else { SourceTextureOverrideLabel = Sampler->SlotDisplayName; } } } } } } } // Create the base texture widget TSharedPtr<IPropertyHandle> SourceTextureProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, SourceTexture)); DetailLayout.HideProperty(SourceTextureProperty); SpriteCategory.AddCustomRow(SourceTextureProperty->GetPropertyDisplayName()) .NameContent() [ CreateTextureNameWidget(SourceTextureProperty, SourceTextureOverrideLabel) ] .ValueContent() .MaxDesiredWidth(TOptional<float>()) [ SourceTextureProperty->CreatePropertyValueWidget() ]; // Create the additional textures widget TSharedPtr<IPropertyHandle> AdditionalSourceTexturesProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, AdditionalSourceTextures)); TSharedRef<FDetailArrayBuilder> AdditionalSourceTexturesBuilder = MakeShareable(new FDetailArrayBuilder(AdditionalSourceTexturesProperty.ToSharedRef())); AdditionalSourceTexturesBuilder->OnGenerateArrayElementWidget(FOnGenerateArrayElementWidget::CreateSP(this, &FSpriteDetailsCustomization::GenerateAdditionalTextureWidget)); SpriteCategory.AddCustomBuilder(AdditionalSourceTexturesBuilder); }
void FAutoReimportManager::HandleLoadingSavingSettingChanged(FName PropertyName) { if (PropertyName == GET_MEMBER_NAME_CHECKED(UEditorLoadingSavingSettings, bMonitorContentDirectories) || PropertyName == GET_MEMBER_NAME_CHECKED(UEditorLoadingSavingSettings, AutoReimportDirectorySettings)) { ResetMonitorsTimeout = FTimeLimit(5.f); } }
UBTDecorator_UtilityBlackboard::UBTDecorator_UtilityBlackboard(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { NodeName = "Blackboard Utility"; // accept only float and integer keys UtilityValueKey.AddFloatFilter(this, GET_MEMBER_NAME_CHECKED(UBTDecorator_UtilityBlackboard, UtilityValueKey)); UtilityValueKey.AddIntFilter(this, GET_MEMBER_NAME_CHECKED(UBTDecorator_UtilityBlackboard, UtilityValueKey)); }
void FBlackboardDataDetails::CustomizeDetails( IDetailLayoutBuilder& DetailLayout ) { // First hide all keys DetailLayout.HideProperty(TEXT("Keys")); DetailLayout.HideProperty(TEXT("ParentKeys")); // Now show only the currently selected key bool bIsInherited = false; int32 CurrentSelection = INDEX_NONE; if(OnGetSelectedBlackboardItemIndex.IsBound()) { CurrentSelection = OnGetSelectedBlackboardItemIndex.Execute(bIsInherited); } if(CurrentSelection >= 0) { TSharedPtr<IPropertyHandle> KeysHandle = bIsInherited ? DetailLayout.GetProperty(TEXT("ParentKeys")) : DetailLayout.GetProperty(TEXT("Keys")); check(KeysHandle.IsValid()); uint32 NumChildKeys = 0; KeysHandle->GetNumChildren(NumChildKeys); if((uint32)CurrentSelection < NumChildKeys) { TSharedPtr<IPropertyHandle> KeyHandle = KeysHandle->GetChildHandle((uint32)CurrentSelection); IDetailCategoryBuilder& DetailCategoryBuilder = DetailLayout.EditCategory("Key"); TSharedPtr<IPropertyHandle> EntryNameProperty = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, EntryName)); DetailCategoryBuilder.AddCustomRow(LOCTEXT("EntryNameLabel", "Entry Name")) .NameContent() [ EntryNameProperty->CreatePropertyNameWidget() ] .ValueContent() [ SNew(SHorizontalBox) .IsEnabled(true) +SHorizontalBox::Slot() [ EntryNameProperty->CreatePropertyValueWidget() ] ]; #if WITH_EDITORONLY_DATA // TSharedPtr<IPropertyHandle> EntryDescriptionHandle = ElementProperty->GetChildHandle("EntryDescription"); TSharedPtr<IPropertyHandle> EntryDescriptionHandle = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, EntryDescription)); DetailCategoryBuilder.AddProperty(EntryDescriptionHandle); #endif TSharedPtr<IPropertyHandle> KeyTypeProperty = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, KeyType)); DetailCategoryBuilder.AddProperty(KeyTypeProperty); TSharedPtr<IPropertyHandle> bInstanceSyncedProperty = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, bInstanceSynced)); DetailCategoryBuilder.AddProperty(bInstanceSyncedProperty); } } }
// Called when property is changed in the Unreal Editor void AVessel::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) { FName PropertyName = (PropertyChangedEvent.Property != NULL) ? PropertyChangedEvent.Property->GetFName() : NAME_None; if (PropertyName == GET_MEMBER_NAME_CHECKED(AVessel, BuildStage) || PropertyName == GET_MEMBER_NAME_CHECKED(AVessel, FinalRotations)) { // Set the Build Stage and Current Rotation accordingly SetBuildStage(BuildStage); } Super::PostEditChangeProperty(PropertyChangedEvent); }
UBTTask_MoveDirectlyToward::UBTTask_MoveDirectlyToward(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) , AcceptableRadius(50.f) , bProjectVectorGoalToNavigation(true) , bAllowStrafe(true) , bStopOnOverlap(false) { NodeName = "MoveDirectlyToward"; // accept only actors and vectors BlackboardKey.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey), AActor::StaticClass()); BlackboardKey.AddVectorFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey)); }
void FNiagaraEmitterPropertiesDetails::OnGenerateScalarConstantEntry(TSharedRef<IPropertyHandle> ElementProperty, int32 ElementIndex, IDetailChildrenBuilder& ChildrenBuilder) { TSharedPtr<IPropertyHandle> ValueProperty = ElementProperty->GetChildHandle(GET_MEMBER_NAME_CHECKED(FNiagaraConstants_Float, Value)); TSharedPtr<IPropertyHandle> NameProperty = ElementProperty->GetChildHandle(GET_MEMBER_NAME_CHECKED(FNiagaraConstants_Float, Name)); FName DisplayName; NameProperty->GetValue(DisplayName); //Don't display system constants if (UNiagaraComponent::GetSystemConstants().Find(FNiagaraVariableInfo(DisplayName, ENiagaraDataType::Scalar)) == INDEX_NONE) { ChildrenBuilder.AddChildProperty(ValueProperty.ToSharedRef()).DisplayName(FText::FromName(DisplayName)); } }
UBTTask_FlyTo::UBTTask_FlyTo(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { NodeName = "Fly To"; bNotifyTick = true; FlightLocationKey.AddVectorFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_FlyTo, FlightLocationKey)); FlightResultKey.AddBoolFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_FlyTo, FlightResultKey)); KeyToFlipFlopWhenTaskExits.AddBoolFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_FlyTo, KeyToFlipFlopWhenTaskExits)); FlightLocationKey.AllowNoneAsValue(true); FlightResultKey.AllowNoneAsValue(true); KeyToFlipFlopWhenTaskExits.AllowNoneAsValue(true); }
void UPaperTileMap::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) { const FName PropertyName = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : NAME_None; //@TODO: Determine when these are really needed, as they're seriously expensive! FTileMapReregisterContext ReregisterTileMapComponents(this); ValidateSelectedLayerIndex(); if (PropertyName == GET_MEMBER_NAME_CHECKED(UPaperTileMap, HexSideLength)) { HexSideLength = FMath::Max<int32>(HexSideLength, 0); // The side length needs to be included in the overall tile height TileHeight += HexSideLength; } TileWidth = FMath::Max(TileWidth, 1); TileHeight = FMath::Max(TileHeight, 1); MapWidth = FMath::Max(MapWidth, 1); MapHeight = FMath::Max(MapHeight, 1); if (PixelsPerUnrealUnit <= 0.0f) { PixelsPerUnrealUnit = 1.0f; } if ((PropertyName == GET_MEMBER_NAME_CHECKED(UPaperTileMap, MapWidth)) || (PropertyName == GET_MEMBER_NAME_CHECKED(UPaperTileMap, MapHeight))) { ResizeMap(MapWidth, MapHeight, /*bForceResize=*/ true); } else { // Make sure that the layers are all of the right size for (UPaperTileLayer* TileLayer : TileLayers) { if ((TileLayer->GetLayerWidth() != MapWidth) || (TileLayer->GetLayerHeight() != MapHeight)) { TileLayer->Modify(); TileLayer->ResizeMap(MapWidth, MapHeight); } } } if (!IsTemplate()) { UpdateBodySetup(); } Super::PostEditChangeProperty(PropertyChangedEvent); }
void FInputAxisMappingCustomization::CustomizeChildren( TSharedRef<class IPropertyHandle> InStructPropertyHandle, class IDetailChildrenBuilder& StructBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils ) { TSharedPtr<IPropertyHandle> KeyHandle = InStructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, Key)); TSharedPtr<IPropertyHandle> ScaleHandle = InStructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, Scale)); TSharedRef<SWidget> RemoveButton = PropertyCustomizationHelpers::MakeDeleteButton( FSimpleDelegate::CreateSP( this, &FInputAxisMappingCustomization::RemoveAxisMappingButton_OnClick), LOCTEXT("RemoveAxisMappingToolTip", "Removes Axis Mapping") ); StructBuilder.AddChildContent( LOCTEXT("KeySearchStr", "Key").ToString() ) [ SNew(SHorizontalBox) + SHorizontalBox::Slot() .Padding(InputConstants::PropertyPadding) .AutoWidth() [ SNew( SBox ) .WidthOverride( InputConstants::TextBoxWidth ) [ StructBuilder.GenerateStructValueWidget( KeyHandle.ToSharedRef() ) ] ] +SHorizontalBox::Slot() .Padding(InputConstants::PropertyPadding) .HAlign(HAlign_Center) .VAlign(VAlign_Center) .AutoWidth() [ ScaleHandle->CreatePropertyNameWidget() ] +SHorizontalBox::Slot() .Padding(InputConstants::PropertyPadding) .HAlign(HAlign_Left) .VAlign(VAlign_Center) .AutoWidth() [ SNew(SBox) .WidthOverride(InputConstants::ScaleBoxWidth) [ ScaleHandle->CreatePropertyValueWidget() ] ] +SHorizontalBox::Slot() .Padding(InputConstants::PropertyPadding) .HAlign(HAlign_Center) .VAlign(VAlign_Center) .AutoWidth() [ RemoveButton ] ]; }
UBTTask_MoveDirectlyToward::UBTTask_MoveDirectlyToward(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) , bProjectVectorGoalToNavigation(true) { NodeName = "MoveDirectlyToward"; AcceptableRadius = GET_AI_CONFIG_VAR(AcceptanceRadius); bStopOnOverlap = GET_AI_CONFIG_VAR(bFinishMoveOnGoalOverlap); bAllowStrafe = GET_AI_CONFIG_VAR(bAllowStrafing); // accept only actors and vectors BlackboardKey.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey), AActor::StaticClass()); BlackboardKey.AddVectorFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey)); }
void UPhysicsSettings::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) { Super::PostEditChangeProperty(PropertyChangedEvent); const FName PropertyName = PropertyChangedEvent.Property ? PropertyChangedEvent.Property->GetFName() : NAME_None; if (PropertyName == GET_MEMBER_NAME_CHECKED(UPhysicsSettings, FrictionCombineMode) || PropertyName == GET_MEMBER_NAME_CHECKED(UPhysicsSettings, RestitutionCombineMode)) { UPhysicalMaterial::RebuildPhysicalMaterials(); } else if (PropertyName == GET_MEMBER_NAME_CHECKED(UPhysicsSettings, DefaultDegreesOfFreedom)) { UMovementComponent::PhysicsLockedAxisSettingChanged(); } }
void UGameplayCueManager::InitObjectLibraries(TArray<FString> Paths, UObjectLibrary* ActorObjectLibrary, UObjectLibrary* StaticObjectLibrary, FOnGameplayCueNotifySetLoaded OnLoadDelegate, FShouldLoadGCNotifyDelegate ShouldLoadDelegate) { DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading Library"), STAT_ObjectLibrary, STATGROUP_LoadTime); #if WITH_EDITOR bAccelerationMapOutdated = false; FFormatNamedArguments Args; FScopedSlowTask SlowTask(0, FText::Format(NSLOCTEXT("AbilitySystemEditor", "BeginLoadingGameplayCueNotify", "Loading GameplayCue Library"), Args)); SlowTask.MakeDialog(); #endif FScopeCycleCounterUObject PreloadScopeActor(ActorObjectLibrary); ActorObjectLibrary->LoadBlueprintAssetDataFromPaths(Paths); StaticObjectLibrary->LoadBlueprintAssetDataFromPaths(Paths); // --------------------------------------------------------- // Determine loading scheme. // Sync at startup in commandlets like cook. // Async at startup in all other cases // --------------------------------------------------------- const bool bSyncFullyLoad = IsRunningCommandlet(); const bool bAsyncLoadAtStartup = !bSyncFullyLoad && ShouldAsyncLoadAtStartup(); if (bSyncFullyLoad) { #if STATS FString PerfMessage = FString::Printf(TEXT("Fully Loaded GameplayCueNotify object library")); SCOPE_LOG_TIME_IN_SECONDS(*PerfMessage, nullptr) #endif ActorObjectLibrary->LoadAssetsFromAssetData(); StaticObjectLibrary->LoadAssetsFromAssetData(); } // --------------------------------------------------------- // Look for GameplayCueNotifies that handle events // --------------------------------------------------------- TArray<FAssetData> ActorAssetDatas; ActorObjectLibrary->GetAssetDataList(ActorAssetDatas); TArray<FAssetData> StaticAssetDatas; StaticObjectLibrary->GetAssetDataList(StaticAssetDatas); TArray<FGameplayCueReferencePair> CuesToAdd; BuildCuesToAddToGlobalSet(ActorAssetDatas, GET_MEMBER_NAME_CHECKED(AGameplayCueNotify_Actor, GameplayCueName), bAsyncLoadAtStartup, CuesToAdd, OnLoadDelegate, ShouldLoadDelegate); BuildCuesToAddToGlobalSet(StaticAssetDatas, GET_MEMBER_NAME_CHECKED(UGameplayCueNotify_Static, GameplayCueName), bAsyncLoadAtStartup, CuesToAdd, OnLoadDelegate, ShouldLoadDelegate); check(GlobalCueSet); GlobalCueSet->AddCues(CuesToAdd); }
void FAxisMappingsNodeBuilder::RebuildGroupedMappings() { GroupedMappings.Empty(); TSharedPtr<IPropertyHandleArray> AxisMappingsArrayHandle = AxisMappingsPropertyHandle->AsArray(); uint32 NumMappings; AxisMappingsArrayHandle->GetNumElements(NumMappings); for (uint32 Index = 0; Index < NumMappings; ++Index) { TSharedRef<IPropertyHandle> AxisMapping = AxisMappingsArrayHandle->GetElement(Index); FName AxisName; FPropertyAccess::Result Result = AxisMapping->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->GetValue(AxisName); if (Result == FPropertyAccess::Success) { int32 FoundIndex = INDEX_NONE; for (int32 GroupIndex = 0; GroupIndex < GroupedMappings.Num(); ++GroupIndex) { if (GroupedMappings[GroupIndex].SharedName == AxisName) { FoundIndex = GroupIndex; break; } } if (FoundIndex == INDEX_NONE) { FoundIndex = GroupedMappings.Num(); GroupedMappings.AddZeroed(); GroupedMappings[FoundIndex].SharedName = AxisName; } GroupedMappings[FoundIndex].Mappings.Add(AxisMapping); } } }
void USoundMix::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) { if (PropertyChangedEvent.ChangeType != EPropertyChangeType::Interactive && PropertyChangedEvent.MemberProperty) { if (PropertyChangedEvent.MemberProperty->GetFName() == GET_MEMBER_NAME_CHECKED(USoundMix,SoundClassEffects)) { TArray<USoundClass*> ProblemClasses; if (CausesPassiveDependencyLoop(ProblemClasses)) { for (int32 Index = 0; Index < ProblemClasses.Num(); Index++) { FFormatNamedArguments Arguments; Arguments.Add(TEXT("SoundClass"), FText::FromString(ProblemClasses[Index]->GetName())); Arguments.Add(TEXT("SoundMix"), FText::FromString(GetName())); FNotificationInfo Info(FText::Format(NSLOCTEXT("Engine", "PassiveSoundMixLoop", "Passive dependency created by Sound Class'{SoundClass}' and Sound Mix'{SoundMix}' - results may be undesirable"), Arguments)); Info.ExpireDuration = 10.0f; Info.Image = FCoreStyle::Get().GetBrush(TEXT("MessageLog.Warning")); FSlateNotificationManager::Get().AddNotification(Info); } } } } #if WITH_EDITORONLY_DATA bChanged = true; #endif }
void USoundWave::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) { Super::PostEditChangeProperty(PropertyChangedEvent); static FName CompressionQualityFName = FName( TEXT( "CompressionQuality" ) ); static FName StreamingFName = GET_MEMBER_NAME_CHECKED(USoundWave, bStreaming); // Prevent constant re-compression of SoundWave while properties are being changed interactively if (PropertyChangedEvent.ChangeType != EPropertyChangeType::Interactive) { UProperty* PropertyThatChanged = PropertyChangedEvent.Property; // Regenerate on save any compressed sound formats if ( PropertyThatChanged && PropertyThatChanged->GetFName() == CompressionQualityFName ) { InvalidateCompressedData(); FreeResources(); UpdatePlatformData(); MarkPackageDirty(); } else if (PropertyThatChanged && PropertyThatChanged->GetFName() == StreamingFName) { FreeResources(); UpdatePlatformData(); MarkPackageDirty(); } } }