void FThumbnailSection::BuildSectionContextMenu(FMenuBuilder& MenuBuilder, const FGuid& ObjectBinding)
{
MenuBuilder.BeginSection(NAME_None, LOCTEXT("ViewMenuText", "View"));
{
MenuBuilder.AddSubMenu(
LOCTEXT("ThumbnailsMenu", "Thumbnails"),
FText(),
FNewMenuDelegate::CreateLambda([=](FMenuBuilder& InMenuBuilder){
TSharedPtr<ISequencer> Sequencer = SequencerPtr.Pin();
FText CurrentTime = FText::FromString(Sequencer->GetZeroPadNumericTypeInterface()->ToString(Sequencer->GetGlobalTime()));
InMenuBuilder.BeginSection(NAME_None, LOCTEXT("ThisSectionText", "This Section"));
{
InMenuBuilder.AddMenuEntry(
LOCTEXT("RefreshText", "Refresh"),
LOCTEXT("RefreshTooltip", "Refresh this section's thumbnails"),
FSlateIcon(),
FUIAction(FExecuteAction::CreateRaw(this, &FThumbnailSection::RedrawThumbnails))
);
InMenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("SetSingleTime", "Set Thumbnail Time To {0}"), CurrentTime),
LOCTEXT("SetSingleTimeTooltip", "Defines the time at which this section should draw its single thumbnail to the current cursor position"),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateLambda([=]{
SetSingleTime(Sequencer->GetGlobalTime());
GetMutableDefault<UMovieSceneUserThumbnailSettings>()->bDrawSingleThumbnails = true;
GetMutableDefault<UMovieSceneUserThumbnailSettings>()->SaveConfig();
})
)
);
}
InMenuBuilder.EndSection();
InMenuBuilder.BeginSection(NAME_None, LOCTEXT("GlobalSettingsText", "Global Settings"));
{
InMenuBuilder.AddMenuEntry(
LOCTEXT("RefreshAllText", "Refresh All"),
LOCTEXT("RefreshAllTooltip", "Refresh all sections' thumbnails"),
FSlateIcon(),
FUIAction(FExecuteAction::CreateLambda([]{
GetDefault<UMovieSceneUserThumbnailSettings>()->BroadcastRedrawThumbnails();
}))
);
FPropertyEditorModule& PropertyModule = FModuleManager::LoadModuleChecked<FPropertyEditorModule>("PropertyEditor");
FDetailsViewArgs Args(false, false, false, FDetailsViewArgs::HideNameArea);
TSharedRef<IDetailsView> DetailView = PropertyModule.CreateDetailView(Args);
DetailView->SetObject(GetMutableDefault<UMovieSceneUserThumbnailSettings>());
InMenuBuilder.AddWidget(DetailView, FText(), true);
}
InMenuBuilder.EndSection();
})
);
}
MenuBuilder.EndSection();
}
void HLODOutliner::FLODActorItem::GenerateContextMenu(FMenuBuilder& MenuBuilder, SHLODOutliner& Outliner)
{
auto SharedOutliner = StaticCastSharedRef<SHLODOutliner>(Outliner.AsShared());
MenuBuilder.AddMenuEntry(LOCTEXT("SelectLODActor", "Select LOD Actor"), FText(), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(&Outliner, &SHLODOutliner::SelectLODActor, AsShared())));
MenuBuilder.AddMenuEntry(LOCTEXT("SelectContainedActors", "Select Contained Actors"), FText(), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(&Outliner, &SHLODOutliner::SelectContainedActors, AsShared())));
if (LODActor->IsDirty())
{
MenuBuilder.AddMenuEntry(LOCTEXT("BuildLODActorMesh", "Build LOD Mesh"), FText(), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(&Outliner, &SHLODOutliner::BuildLODActor, AsShared())));
}
else
{
MenuBuilder.AddMenuEntry(LOCTEXT("ForceView", "ForceView"), FText(), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(&Outliner, &SHLODOutliner::ForceViewLODActor, AsShared())));
}
AActor* Actor = LODActor.Get();
ALODActor* ParentActor = HierarchicalLODUtils::GetParentLODActor(Actor);
if (ParentActor && Parent.Pin()->GetTreeItemType() == TreeItemType::HierarchicalLODActor)
{
MenuBuilder.AddMenuEntry(LOCTEXT("RemoveChildFromCluster", "Remove from cluster"), FText(), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(&Outliner, &SHLODOutliner::RemoveLODActorFromCluster, AsShared())));
}
else
{
MenuBuilder.AddMenuEntry(LOCTEXT("DeleteCluster", "Delete Cluster"), FText(), FSlateIcon(), FUIAction(FExecuteAction::CreateSP(&Outliner, &SHLODOutliner::DeleteCluster, AsShared())));
}
}
static FText GetTrafficLightAsText(ETrafficLightState State)
{
switch (State) {
case ETrafficLightState::Green: return FText(LOCTEXT("GreenTrafficLight", "Green"));
case ETrafficLightState::Yellow: return FText(LOCTEXT("YellowTrafficLight", "Yellow"));
case ETrafficLightState::Red: return FText(LOCTEXT("RedTrafficLight", "Red"));
default: return FText(LOCTEXT("InvalidTrafficLight", "INVALID"));
}
}
END_SLATE_FUNCTION_BUILD_OPTIMIZATION
FText SBlendProfilePicker::GetSelectedProfileName() const
{
if(SelectedProfile)
{
return FText::Format(FText(LOCTEXT("SelectedNameEntry", "{0}")), FText::FromString(SelectedProfile->GetName()));
}
return FText(LOCTEXT("NoSelectionEntry", "None"));
}
void FWorldTreeItem::GenerateContextMenu(FMenuBuilder& MenuBuilder, SSceneOutliner& Outliner)
{
auto SharedOutliner = StaticCastSharedRef<SSceneOutliner>(Outliner.AsShared());
const FSlateIcon WorldSettingsIcon(FEditorStyle::GetStyleSetName(), "LevelEditor.WorldProperties.Tab");
const FSlateIcon NewFolderIcon(FEditorStyle::GetStyleSetName(), "SceneOutliner.NewFolderIcon");
MenuBuilder.AddMenuEntry(LOCTEXT("CreateFolder", "Create Folder"), FText(), NewFolderIcon, FUIAction(FExecuteAction::CreateSP(this, &FWorldTreeItem::CreateFolder, TWeakPtr<SSceneOutliner>(SharedOutliner))));
MenuBuilder.AddMenuEntry(LOCTEXT("OpenWorldSettings", "World Settings"), FText(), WorldSettingsIcon, FExecuteAction::CreateSP(this, &FWorldTreeItem::OpenWorldSettings));
}
FText FBehaviorTreeDebugger::FindValueForKey(const FName& InKeyName, bool bUseCurrentState) const
{
#if USE_BEHAVIORTREE_DEBUGGER
if (IsDebuggerRunning() &&
TreeInstance.IsValid())
{
const TMap<FName, FString>* MapToQuery = nullptr;
if(bUseCurrentState)
{
MapToQuery = &CurrentValues;
}
else if(TreeInstance->DebuggerSteps.IsValidIndex(ActiveStepIndex))
{
MapToQuery = &TreeInstance->DebuggerSteps[ActiveStepIndex].BlackboardValues;
}
if(MapToQuery != nullptr)
{
const FString* FindValue = MapToQuery->Find(InKeyName);
if(FindValue != nullptr)
{
return FText::FromString(*FindValue);
}
}
}
return FText();
#endif
}
TSharedRef<ITableRow> SLargeAssetTypeTreeWidget::TreeView_OnGenerateRow(
FLargeAssetTypeTreeItemPtr Item, const TSharedRef<STableViewBase>& OwnerTable
)
{
return
SNew(STableRow<FLargeAssetTypeTreeItemPtr>, OwnerTable)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SCheckBox)
.IsChecked(
this, &SLargeAssetTypeTreeWidget::TreeView_IsChecked,
FLargeAssetTypeTreeItemWeakPtr(Item)
)
.OnCheckStateChanged(
this, &SLargeAssetTypeTreeWidget::TreeView_OnCheckStateChanged,
FLargeAssetTypeTreeItemWeakPtr(Item)
)
]
+ SHorizontalBox::Slot()
[
SNew(STextBlock)
.Text(Item->Title)
.ToolTipText(
!Item->AssetTypeClassName.IsEmpty() ?
FText::Format(LOCTEXT("SLargeAssetTypeTreeWidget_ToolTip", "Class: {0}"),
FText::FromString(Item->AssetTypeClassName)
) : FText()
)
]
];
}
FText SSessionLauncherCookPage::HandleCookModeComboButtonContentText( ) const
{
ILauncherProfilePtr SelectedProfile = Model->GetSelectedProfile();
if (SelectedProfile.IsValid())
{
ELauncherProfileCookModes::Type CookMode = SelectedProfile->GetCookMode();
if (CookMode == ELauncherProfileCookModes::ByTheBook)
{
return LOCTEXT("CookModeComboButton_ByTheBook", "By the book");
}
if (CookMode == ELauncherProfileCookModes::DoNotCook)
{
return LOCTEXT("CookModeComboButton_DoNotCook", "Do not cook");
}
if (CookMode == ELauncherProfileCookModes::OnTheFly)
{
return LOCTEXT("CookModeComboButton_OnTheFly", "On the fly");
}
return LOCTEXT("CookModeComboButtonDefaultText", "Select...");
}
return FText();
}
FText FGitSourceControlState::GetDisplayTooltip() const
{
switch(WorkingCopyState) //-V719
{
case EWorkingCopyState::Unknown:
return LOCTEXT("Unknown_Tooltip", "Unknown source control state");
case EWorkingCopyState::Unchanged:
return LOCTEXT("Pristine_Tooltip", "There are no modifications");
case EWorkingCopyState::Added:
return LOCTEXT("Added_Tooltip", "Item is scheduled for addition");
case EWorkingCopyState::Deleted:
return LOCTEXT("Deleted_Tooltip", "Item is scheduled for deletion");
case EWorkingCopyState::Modified:
return LOCTEXT("Modified_Tooltip", "Item has been modified");
case EWorkingCopyState::Conflicted:
return LOCTEXT("ContentsConflict_Tooltip", "The contents (as opposed to the properties) of the item conflict with updates received from the repository.");
case EWorkingCopyState::Ignored:
return LOCTEXT("Ignored_Tooltip", "Item is being ignored.");
case EWorkingCopyState::Merged:
return LOCTEXT("Merged_Tooltip", "Item has been merged.");
case EWorkingCopyState::NotControlled:
return LOCTEXT("NotControlled_Tooltip", "Item is not under version control.");
case EWorkingCopyState::Missing:
return LOCTEXT("Missing_Tooltip", "Item is missing (e.g., you moved or deleted it without using Git). This also indicates that a directory is incomplete (a checkout or update was interrupted).");
}
return FText();
}
FText FGitSourceControlState::GetDisplayName() const
{
switch(WorkingCopyState)
{
case EWorkingCopyState::Unknown:
return LOCTEXT("Unknown", "Unknown");
case EWorkingCopyState::Unchanged:
return LOCTEXT("Unchanged", "Unchanged");
case EWorkingCopyState::Added:
return LOCTEXT("Added", "Added");
case EWorkingCopyState::Deleted:
return LOCTEXT("Deleted", "Deleted");
case EWorkingCopyState::Modified:
return LOCTEXT("Modified", "Modified");
case EWorkingCopyState::Renamed:
return LOCTEXT("Renamed", "Renamed");
case EWorkingCopyState::Copied:
return LOCTEXT("Copied", "Copied");
case EWorkingCopyState::Conflicted:
return LOCTEXT("ContentsConflict", "Contents Conflict");
case EWorkingCopyState::Ignored:
return LOCTEXT("Ignored", "Ignored");
case EWorkingCopyState::Merged:
return LOCTEXT("Merged", "Merged");
case EWorkingCopyState::NotControlled:
return LOCTEXT("NotControlled", "Not Under Source Control");
case EWorkingCopyState::Missing:
return LOCTEXT("Missing", "Missing");
}
return FText();
}
FText UFlareFactory::GetFactoryCycleCost(const FFlareProductionData* Data)
{
FText ProductionCostText;
FText CommaTextReference = UFlareGameTools::AddLeadingSpace(LOCTEXT("Comma", "+"));
// Cycle cost in credits
uint32 CycleProductionCost = GetProductionCost(Data);
if (CycleProductionCost > 0)
{
ProductionCostText = FText::Format(LOCTEXT("ProductionCostFormat", "{0} credits"), FText::AsNumber(UFlareGameTools::DisplayMoney(CycleProductionCost)));
}
// Cycle cost in resources
for (int ResourceIndex = 0; ResourceIndex < Data->InputResources.Num(); ResourceIndex++)
{
FText CommaText = ProductionCostText.IsEmpty() ? FText() : CommaTextReference;
const FFlareFactoryResource* FactoryResource = &Data->InputResources[ResourceIndex];
FCHECK(FactoryResource);
ProductionCostText = FText::Format(LOCTEXT("ProductionResourcesFormat", "{0}{1} {2} {3}"),
ProductionCostText, CommaText, FText::AsNumber(FactoryResource->Quantity), FactoryResource->Resource->Data.Acronym);
}
return ProductionCostText;
}
FText FWindowsErrorReport::DiagnoseReport() const
{
// Mark the callstack as invalid.
bValidCallstack = false;
// Should check if there are local PDBs before doing anything
auto CrashDebugHelper = CrashHelperModule ? CrashHelperModule->Get() : nullptr;
if (!CrashDebugHelper)
{
// Not localized: should never be seen
return FText::FromString(TEXT("Failed to load CrashDebugHelper."));
}
FString DumpFilename;
if (!FindFirstReportFileWithExtension(DumpFilename, TEXT(".dmp")))
{
if (!FindFirstReportFileWithExtension(DumpFilename, TEXT(".mdmp")))
{
return LOCTEXT("MinidumpNotFound", "No minidump found for this crash.");
}
}
if (!CrashDebugHelper->CreateMinidumpDiagnosticReport(ReportDirectory / DumpFilename))
{
return LOCTEXT("NoDebuggingSymbols", "You do not have any debugging symbols required to display the callstack for this crash.");
}
// No longer required, only for backward compatibility, mark the callstack as valid.
bValidCallstack = true;
return FText();
}
FText FTextFormatter::Format(FTextFormat&& InFmt, FFormatOrderedArguments&& InArguments, const bool bInRebuildText, const bool bInRebuildAsSource)
{
checkf(FInternationalization::Get().IsInitialized() == true, TEXT("FInternationalization is not initialized. An FText formatting method was likely used in static object initialization - this is not supported."));
int32 EstimatedArgumentValuesLength = 0;
for (const auto& Arg : InArguments)
{
EstimatedArgumentValuesLength += EstimateArgumentValueLength(Arg);
}
const FString& FmtPattern = InFmt.GetSourceString();
auto GetArgumentValue = [&InArguments, &FmtPattern](const TextFormatTokens::FArgumentTokenSpecifier& ArgumentToken, int32 ArgumentNumber) -> const FFormatArgumentValue*
{
int32 ArgumentIndex = ArgumentToken.ArgumentIndex;
if (ArgumentIndex == INDEX_NONE)
{
// We failed to parse the argument name into a number...
// We have existing code that is incorrectly using names in the format string when providing ordered arguments
// ICU used to fallback to treating the index of the argument within the string as if it were the index specified
// by the argument name, so we need to emulate that behavior to avoid breaking some format operations
UE_LOG(LogTextFormatter, Warning, TEXT("Failed to parse argument \"%s\" as a number (using \"%d\" as a fallback). Please check your format string for errors: \"%s\"."), *FString(ArgumentToken.ArgumentNameLen, ArgumentToken.ArgumentNameStartPos), ArgumentNumber, *FmtPattern);
ArgumentIndex = ArgumentNumber;
}
return InArguments.IsValidIndex(ArgumentIndex) ? &(InArguments[ArgumentIndex]) : nullptr;
};
FString ResultString = Format(InFmt, FPrivateTextFormatArguments(FPrivateTextFormatArguments::FGetArgumentValue(GetArgumentValue), EstimatedArgumentValuesLength, bInRebuildText, bInRebuildAsSource));
FText Result = FText(MakeShareable(new TGeneratedTextData<FTextHistory_OrderedFormat>(MoveTemp(ResultString), FTextHistory_OrderedFormat(MoveTemp(InFmt), MoveTemp(InArguments)))));
if (!GIsEditor)
{
Result.Flags |= ETextFlag::Transient;
}
return Result;
}
//@todo this is deprecated and shouldn't be used anymore [6/4/2014 justin.sargent]
FText FBuildPatchInstaller::GetDownloadSpeedText()
{
static const FText DownloadSpeedFormat = LOCTEXT("BuildPatchInstaller_DownloadSpeedFormat", "{Current} / {Total} ({Speed}/sec)");
FScopeLock Lock(&ThreadLock);
FText SpeedDisplayedText;
if (DownloadSpeedValue >= 0)
{
FNumberFormattingOptions SpeedFormattingOptions;
SpeedFormattingOptions.MaximumFractionalDigits = 1;
SpeedFormattingOptions.MinimumFractionalDigits = 0;
FNumberFormattingOptions SizeFormattingOptions;
SizeFormattingOptions.MaximumFractionalDigits = 1;
SizeFormattingOptions.MinimumFractionalDigits = 1;
FFormatNamedArguments Args;
Args.Add(TEXT("Speed"), FText::AsMemory(DownloadSpeedValue, &SpeedFormattingOptions));
Args.Add(TEXT("Total"), FText::AsMemory(TotalInitialDownloadSize, &SizeFormattingOptions));
Args.Add(TEXT("Current"), FText::AsMemory(TotalInitialDownloadSize - DownloadBytesLeft, &SizeFormattingOptions));
return FText::Format(DownloadSpeedFormat, Args);
}
return FText();
}
TSharedRef<SWidget> FReportWidgetGenerator::GetWidget()
{
auto progress = Generator->GetProgress();
if (progress == FAsyncReportGenerator::EProgress::COMPILATION_COMPLETE)
{
if (!CachedReportWidget.IsValid())
{
// Make the widget once then cache it
CachedReportWidget = ConstructReportWidget(Generator.Get());
}
return CachedReportWidget.ToSharedRef();
}
else
{
// Set the throbber text depending on how far through compilation we are
if (progress == FAsyncReportGenerator::EProgress::CROSS_COMPILATION_IN_PROGRESS)
{
ThrobberTextLine1->SetText(FText::FromString(TEXT("Compiling HLSL to GLSL")));
ThrobberTextLine2->SetText(FText());
}
else
{
check(progress == FAsyncReportGenerator::EProgress::MALIOC_COMPILATION_IN_PROGRESS);
const auto oscProgress = Generator->GetMaliOCCompilationProgress();
ThrobberTextLine1->SetText(FText::FromString(TEXT("Compiling Shaders")));
ThrobberTextLine2->SetText(FText::FromString(FString::Printf(TEXT("%u / %u"), oscProgress.NumCompiledShaders, oscProgress.NumTotalShaders)));
}
return ThrobberWidget.ToSharedRef();
}
}
FText FFlareTransactionLogEntry::GetCategoryDescription(EFlareTransactionLogEntry::Type Type)
{
switch (Type)
{
case EFlareTransactionLogEntry::ManualResourcePurchase: return LOCTEXT("CategoryManualResourcePurchase", "Resources purchases"); break;
case EFlareTransactionLogEntry::ManualResourceSell: return LOCTEXT("CategoryManualResourceSell", "Resources sales"); break;
case EFlareTransactionLogEntry::TradeRouteResourcePurchase: return LOCTEXT("CategoryTradeRouteResourcePurchase", "Trade route purchases"); break;
case EFlareTransactionLogEntry::TradeRouteResourceSell: return LOCTEXT("CategoryTradeRouteResourceSell", "Trade route sales"); break;
case EFlareTransactionLogEntry::FactoryWages: return LOCTEXT("CategoryFactoryWages", "Factory wages"); break;
case EFlareTransactionLogEntry::CancelFactoryWages: return LOCTEXT("CategoryCancelFactoryWages", "Factory wages cancelled"); break;
case EFlareTransactionLogEntry::StationConstructionFees: return LOCTEXT("CategoryStationConstructionFees", "Station construction"); break;
case EFlareTransactionLogEntry::StationUpgradeFees: return LOCTEXT("CategoryStationUpgradeFees", "Station upgrades"); break;
case EFlareTransactionLogEntry::CancelStationUpgradeFees: return LOCTEXT("CategoryCancelStationUpgradeFees", "Station upgrades refunds"); break;
case EFlareTransactionLogEntry::UpgradeShipPart: return LOCTEXT("CategoryUpgradeShipPart", "Ship upgrades"); break;
case EFlareTransactionLogEntry::OrderShip: return LOCTEXT("CategoryOrderShip", "Ship construction"); break;
case EFlareTransactionLogEntry::CancelOrderShip: return LOCTEXT("CategoryCancelOrderShip", "Ship construction refunds"); break;
case EFlareTransactionLogEntry::OrderShipAdvance: return LOCTEXT("CategoryOrderShipAdvance", "Ship construction advances"); break;
case EFlareTransactionLogEntry::PeoplePurchase: return LOCTEXT("CategoryPeoplePurchase", "Population purchases"); break;
case EFlareTransactionLogEntry::InitialMoney: return LOCTEXT("CategoryInitialMoney", "Initial capital"); break;
case EFlareTransactionLogEntry::PayRepair: return LOCTEXT("CategoryPayRepair", "Ship repairs"); break;
case EFlareTransactionLogEntry::PayRefill: return LOCTEXT("CategoryPayRefill", "Ship refilling"); break;
case EFlareTransactionLogEntry::PaidForRepair: return LOCTEXT("CategoryPaidForRepair", "Ship repair services"); break;
case EFlareTransactionLogEntry::PaidForRefill: return LOCTEXT("CategoryPaidForRefill", "Ship refilling services"); break;
case EFlareTransactionLogEntry::SendTribute: return LOCTEXT("CategorySendTribute", "Tributes paid"); break;
case EFlareTransactionLogEntry::ReceiveTribute: return LOCTEXT("CategoryReceiveTribute", "Tributes received"); break;
case EFlareTransactionLogEntry::RecoveryFees: return LOCTEXT("CategoryRecoveryFees", "Ship recovery"); break;
case EFlareTransactionLogEntry::ScrapGain: return LOCTEXT("CategoryScrapGain", "Ship scrapping"); break;
case EFlareTransactionLogEntry::Cheat: return LOCTEXT("CategoryCheat", "Unlawful transactions"); break;
case EFlareTransactionLogEntry::QuestReward: return LOCTEXT("CategoryQuestReward", "Contracts"); break;
case EFlareTransactionLogEntry::MutualAssistance: return LOCTEXT("CategoryMutualAssistance", "Mutual assistance"); break;
case EFlareTransactionLogEntry::ScrapCost: return LOCTEXT("CategoryScrapCost", "Ship scrapping costs"); break;
}
return FText();
}
FText FTextHistory_AsCurrency::ToText(bool bInAsSource) const
{
TSharedPtr< FCulture, ESPMode::ThreadSafe > CurrentCulture = bInAsSource? FInternationalization::Get().GetInvariantCulture() : TargetCulture;
switch(SourceValue.Type)
{
case EFormatArgumentType::UInt:
{
return FText::AsCurrency(SourceValue.UIntValue, CurrencyCode, FormatOptions, CurrentCulture);
}
case EFormatArgumentType::Int:
{
return FText::AsCurrency(SourceValue.IntValue, CurrencyCode, FormatOptions, CurrentCulture);
}
case EFormatArgumentType::Float:
{
return FText::AsCurrency(SourceValue.FloatValue, CurrencyCode, FormatOptions, CurrentCulture);
}
case EFormatArgumentType::Double:
{
return FText::AsCurrency(SourceValue.DoubleValue, CurrencyCode, FormatOptions, CurrentCulture);
}
default:
{
// Should never reach this point
check(0);
}
}
return FText();
}
FText FTextFormatter::Format(FTextFormat&& InFmt, FFormatNamedArguments&& InArguments, const bool bInRebuildText, const bool bInRebuildAsSource)
{
checkf(FInternationalization::Get().IsInitialized() == true, TEXT("FInternationalization is not initialized. An FText formatting method was likely used in static object initialization - this is not supported."));
int32 EstimatedArgumentValuesLength = 0;
for (const auto& Pair : InArguments)
{
EstimatedArgumentValuesLength += EstimateArgumentValueLength(Pair.Value);
}
auto GetArgumentValue = [&InArguments](const TextFormatTokens::FArgumentTokenSpecifier& ArgumentToken, int32 ArgumentNumber) -> const FFormatArgumentValue*
{
for (const auto& Pair : InArguments)
{
if (ArgumentToken.ArgumentNameLen == Pair.Key.Len() && FCString::Strnicmp(ArgumentToken.ArgumentNameStartPos, *Pair.Key, ArgumentToken.ArgumentNameLen) == 0)
{
return &Pair.Value;
}
}
return nullptr;
};
FString ResultString = Format(InFmt, FPrivateTextFormatArguments(FPrivateTextFormatArguments::FGetArgumentValue(GetArgumentValue), EstimatedArgumentValuesLength, bInRebuildText, bInRebuildAsSource));
FText Result = FText(MakeShareable(new TGeneratedTextData<FTextHistory_NamedFormat>(MoveTemp(ResultString), FTextHistory_NamedFormat(MoveTemp(InFmt), MoveTemp(InArguments)))));
if (!GIsEditor)
{
Result.Flags |= ETextFlag::Transient;
}
return Result;
}
static FText GetGearAsText(int32 Gear)
{
if (Gear < 0) {
return FText(LOCTEXT("ReverseGear", "R"));
} else {
return (Gear == 0 ? LOCTEXT("NeutralGear", "N") : FText::AsNumber(Gear));
}
}
FText FActorInfoColumn::GetSelectedMode() const
{
if (CurrentMode == ECustomColumnMode::None)
{
return FText();
}
return MakeComboText(CurrentMode);
}
void UEnvironmentQueryGraphNode_Option::CreateAddTestSubMenu(class FMenuBuilder& MenuBuilder, UEdGraph* Graph) const
{
TSharedRef<SGraphEditorActionMenuAI> Menu =
SNew(SGraphEditorActionMenuAI)
.GraphObj( Graph )
.GraphNode((UEnvironmentQueryGraphNode_Option*)this)
.AutoExpandActionMenu(true);
MenuBuilder.AddWidget(Menu,FText(),true);
}
TSharedRef<SWidget> FSequencerTimeSliderController::OpenSetPlaybackRangeMenu(float MouseTime)
{
const bool bShouldCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder(bShouldCloseWindowAfterMenuSelection, nullptr);
FText NumericText;
if (SequencerSnapValues::IsTimeSnapIntervalFrameRate(TimeSliderArgs.Settings->GetTimeSnapInterval()) && TimeSliderArgs.Settings->GetShowFrameNumbers())
{
NumericText = FText::Format(LOCTEXT("FrameTextFormat", "Playback Range (at frame {0}):"), FText::AsNumber(TimeToFrame(MouseTime)));
}
else
{
NumericText = FText::Format(LOCTEXT("TimeTextFormat", "Playback Range (at {0}s):"), FText::AsNumber(MouseTime));
}
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
MenuBuilder.BeginSection("SequencerPlaybackRangeMenu", NumericText);
{
MenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("SetPlaybackStart", "Set Start Time"), NumericText),
FText(),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateLambda([=]{ return SetPlaybackRangeStart(MouseTime); }),
FCanExecuteAction::CreateLambda([=]{ return MouseTime <= PlaybackRange.GetUpperBoundValue(); })
)
);
MenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("SetPlaybackEnd", "Set End Time"), NumericText),
FText(),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateLambda([=]{ return SetPlaybackRangeEnd(MouseTime); }),
FCanExecuteAction::CreateLambda([=]{ return MouseTime >= PlaybackRange.GetLowerBoundValue(); })
)
);
}
MenuBuilder.EndSection(); // SequencerPlaybackRangeMenu
return MenuBuilder.MakeWidget();
}
FText FLandscapeEditorDetails::GetTargetLandscapeName()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->CurrentToolTarget.LandscapeInfo.IsValid())
{
return FText::FromString(LandscapeEdMode->CurrentToolTarget.LandscapeInfo->GetLandscapeProxy()->GetActorLabel());
}
return FText();
}
void UEditorLoadingSavingSettings::CheckSourceControlCompatability()
{
if (!bEnableSourceControlCompatabilityCheck || !bMonitorContentDirectories)
{
return;
}
if (ISourceControlModule::Get().IsEnabled() && bDetectChangesOnRestart)
{
// Persistent shared payload captured by the lambdas below
struct FPersistentPayload { TSharedPtr<SNotificationItem> Notification; };
TSharedRef<FPersistentPayload> Payload = MakeShareable(new FPersistentPayload);
FNotificationInfo Info(LOCTEXT("AutoReimport_NotificationTitle", "We noticed that your auto-reimport settings are set up to detect source content changes on restart.\nThis might cause unexpected behavior when starting up after getting latest from source control.\n\nWe recommend disabling this specific behavior."));
auto OnTurnOffClicked = [=]{
auto* Settings = GetMutableDefault<UEditorLoadingSavingSettings>();
Settings->bDetectChangesOnRestart = false;
Settings->SaveConfig();
Payload->Notification->SetEnabled(false);
Payload->Notification->Fadeout();
};
Info.ButtonDetails.Emplace(LOCTEXT("AutoReimport_TurnOff", "Don't detect changes on start-up"), FText(), FSimpleDelegate::CreateLambda(OnTurnOffClicked), SNotificationItem::ECompletionState::CS_None);
auto OnIgnoreClicked = [=]{
Payload->Notification->SetEnabled(false);
Payload->Notification->Fadeout();
};
Info.ButtonDetails.Emplace(LOCTEXT("AutoReimport_Ignore", "Ignore"), FText(), FSimpleDelegate::CreateLambda(OnIgnoreClicked), SNotificationItem::ECompletionState::CS_None);
Info.bUseLargeFont = false;
Info.bFireAndForget = false;
Info.CheckBoxStateChanged = FOnCheckStateChanged::CreateLambda([](ECheckBoxState State){
GetMutableDefault<UEditorLoadingSavingSettings>()->bEnableSourceControlCompatabilityCheck = (State != ECheckBoxState::Checked);
});
Info.CheckBoxText = LOCTEXT("AutoReimport_DontShowAgain", "Don't show again");
Info.Hyperlink = FSimpleDelegate::CreateLambda([]{
// Open Settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
// Ensure that the advanced properties are visible
GConfig->SetBool(TEXT("DetailCategoriesAdvanced"), TEXT("EditorLoadingSavingSettings.AutoReimport"), true, GEditorPerProjectIni);
SettingsModule->ShowViewer("Editor", "General", "LoadingSaving");
}
});
Info.HyperlinkText = LOCTEXT("AutoReimport_OpenSettings", "Settings");
Payload->Notification = FSlateNotificationManager::Get().AddNotification(Info);
}
}
void UBehaviorTreeGraphNode::CreateAddServiceSubMenu(class FMenuBuilder& MenuBuilder, UEdGraph* Graph) const
{
TSharedRef<SGraphEditorActionMenu_BehaviorTree> Menu =
SNew(SGraphEditorActionMenu_BehaviorTree)
.GraphObj( Graph )
.GraphNode((UBehaviorTreeGraphNode*)this)
.SubNodeType(ESubNode::Service)
.AutoExpandActionMenu(true);
MenuBuilder.AddWidget(Menu,FText(),true);
}
FText SWorldLayerButton::GetToolTipText() const
{
if (WorldLayer.DistanceStreamingEnabled)
{
return FText::Format(LOCTEXT("Layer_Distance_Tooltip", "Streaming Distance: {0}"), FText::AsNumber(WorldLayer.StreamingDistance));
}
else
{
return FText(LOCTEXT("Layer_DisabledDistance_Tooltip", "Distance Streaming Disabled"));
}
}
FText FAssetImportDataCustomization::GetFilenameText(int32 Index) const
{
if (FAssetImportInfo* Info = GetEditStruct())
{
if (Info->SourceFiles.IsValidIndex(Index))
{
return FText::FromString(Info->SourceFiles[Index].RelativeFilename);
}
}
return FText();
}
FText FAssetImportDataCustomization::GetTimestampText(int32 Index) const
{
if (FAssetImportInfo* Info = GetEditStruct())
{
if (Info->SourceFiles.IsValidIndex(Index))
{
return FText::FromString(Info->SourceFiles[Index].Timestamp.ToString());
}
}
return FText();
}
FText SAssetTreeItem::GetNameText() const
{
if ( TreeItem.IsValid() )
{
return FText::FromString(TreeItem.Pin()->FolderName);
}
else
{
return FText();
}
}
FText SAssetTreeItem::GetToolTipText() const
{
TSharedPtr<FTreeItem> TreeItemPin = TreeItem.Pin();
if ( TreeItemPin.IsValid() )
{
return FText::FromString(TreeItemPin->FolderPath);
}
else
{
return FText();
}
}
