izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
30f891786a7474fdb129b8817c716440f58dca36
UnrealEngineUWP/Engine/Source/Editor/EditorWidgets/Private/STextPropertyEditableTextBox.cpp
Ben Marsh 30f891786a Copying //UE4/Dev-Core to //UE4/Dev-Main (Source: //UE4/Dev-Core @ 3847469) 
#lockdown Nick.Penwarden
#rb none

============================
  MAJOR FEATURES & CHANGES
============================

Change 3805828 by Gil.Gribb

	UE4 - Fixed a bug in the lock free stalling task queue and adjusted a comment. The code is not current used, so this is not actually change the way the code works.

Change 3806784 by Ben.Marsh

	UAT: Remove code to compile UBT when using UE4Build. It should already be compiled as a dependency of UAT.

Change 3807549 by Graeme.Thornton

	Add a cook timer around VerifyCanCookPackage. A licensee reports this taking a lot of time so it'll be good to account for it.

Change 3807727 by Graeme.Thornton

	Unhide the text asset format experimental editor option

Change 3807746 by Josh.Engebretson

	Remove WER from iOS platform

Change 3807928 by Robert.Manuszewski

	When async loading, GC Clusters will be created after packages have been processed to avoid situations where some of the objects that are being added to a cluster haven't been fully loaded yet

Change 3808221 by Steve.Robb

	GitHub #4307 - Made GetModulePtr() thread safe by not using GetModule()

	^ I'm not convinced by how much thread-safer this is really, but it's tidier anyway.

Change 3809233 by Graeme.Thornton

	TBA: Misc changes to text asset commandlet
	 - Rename mode to "loadsave"
	 - Add -outputFormat option which can be assigned "text" or "binary"
	 - When saving binary, use a differentiated filename so that source assets aren't overwritten

Change 3809518 by Ben.Marsh

	Remove the outdated UnrealSync automation script.

Change 3809643 by Steve.Robb

	GitHub #4277 : fix bug; FMath::FormatIntToHumanReadable 3rd comma and negative value

	#jira UE-53037

Change 3809862 by Steve.Robb

	GitHub #3342 : [FRotator.h] Fix to DecompressAxisFromByte to be more efficient and reflect its intent accurately

	#jira UE-42593

Change 3811190 by Graeme.Thornton

	Add support for writing specific log channels to their own files

Change 3811197 by Graeme.Thornton

	Minor updates to output formatting and timing for the text asset commandlet

Change 3811257 by Robert.Manuszewski

	Cluster creation will now be time-sliced

Change 3811565 by Steve.Robb

	Define out non-monolithic module functions.

Change 3812561 by Steve.Robb

	GitHub #3886 : Enable Brace-Initialization for Declaring Variables

	Incorrect semi-colon search removed after discussion with author.
	Test added.

	#jira UE-48242

Change 3812864 by Steve.Robb

	Removal of some unproven code which was supposed to fix hot reloading BP class functions in plugins.

	See: https://udn.unrealengine.com/questions/376978/aitask-blueprint-nodes-disappear-when-their-module.html

	#jira UE-53089

Change 3820358 by Ben.Marsh

	PR #4358: Incredibuild use ShowAgent by default (Contributed by projectgheist)


Change 3822594 by Ben.Marsh

	UAT: Improvements to log file handling.

	- Always create log files in the final location, rather than writing to a temp directory and copying in later.
	- Now supports -Verbose and -VeryVerbose for increasing log verbosity, rather than -Verbose=XXX.
	- Keep a backlog of log output before the log system is initialized, and flush it to the log file once it is.
	- Allow buildmachines to specify the uebp_FinalLogFolder environment variable, which is used to form paths for display. When build machines copy log files elsewhere after UAT finishes (eg. a network share), this allows error messages to display the right location.

Change 3823695 by Ben.Marsh

	UGS: Fix issue where precompiled binaries would not be shown as available for a change until scrolling the last submitted code change into the buffer (other symptoms, like de-focussing the main window would cause it to go back to an unavailable state, since the changes buffer was shrunk).

	Now always queries changes up to the last change for which zipped binaries are available.

Change 3823845 by Ben.Marsh

	UBT: Exclude C# projects for unsupported platforms when generating project files.

Change 3824180 by Ben.Marsh

	UGS: Add an option to show changes by build machines, and move the "only show reviewed" option in there too (Options > Show Changes).

	#jira

Change 3825777 by Steve.Robb

	Fix to return value of StringToBytes.

Change 3825810 by Ben.Marsh

	UBT: Reduce length of include paths for MSVC toolchain.

Change 3825822 by Robert.Manuszewski

	Optimized PIE lazy pointer fixup. Should be up to 8x faster now.

Change 3826734 by Ben.Marsh

	Remove code to disable TextureFormatAndroid on Linux. It seems to be an editor dependency.

Change 3827730 by Steve.Robb

	Try to avoid decltype(auto) if it's not supported.

	See: https://udn.unrealengine.com/questions/395644/build-417-with-c11-on-linux-ttuple-errors.html

Change 3827745 by Steve.Robb

	Initializer list support for TMap.

Change 3827770 by Steve.Robb

	GitHub #4399 : Added a CONSTEXPR qualifiers to FVariant::GetType()

	#jira UE-53813

Change 3829189 by Ben.Marsh

	UBT: Now always writes a minimal log file. By default, just contains the regular console output and any reasons why actions are outdated and needed to be executed. UAT directs child UBT instances to output logs into its own log folder, so that build machines can save them off.

Change 3830444 by Steve.Robb

	BuildVersion and ModuleManifest moved to Core, and parsing of these files reimplemented to avoid a JSON library.
	This should be revisited when Core has its own JSON library.

Change 3830718 by Ben.Marsh

	Fix incorrect group name being returned by FStatNameAndInfo::GetGroupName() for stat groups.

	The editor populates the viewport stats list by calling this for every registered stat and stat group (via FLevelViewportCommands::HandleNewStatGroup). The menu entry attempts to show the stat name with STAT_XXX stripped from the start as the menu item label, with the free-form text description as a tooltip.

	For stat groups, the it would previously just return the stat group name as "Groups" (due to the raw naming convention of "//Groups//STATGROUP_Foo//..."). Since this didn't match the expected naming convention in FLevelViewportCommands::HandleNewStat (ie. STAT_XXX or STATGROUP_XXX), it would fail to add it.

	When the first actual stat belonging to that group is added, it would add a menu entry for the group based on that, but the stat description no longer makes sense as a tooltip for the group. As a result, all the editor tooltips were junk.

	#jira UE-53845

Change 3831064 by Ben.Marsh

	Fix log file contention when spawning UBT recursively.

Change 3832654 by Ben.Marsh

	UGS: Fix error panel not being selected when opened, and weird alignment/color issues on it.

Change 3832680 by Ben.Marsh

	UGS: Fix failing to detect workspace if synced to a different stream. Seems to be a regression caused by recent P4D upgrade.

Change 3832695 by Ben.Marsh

	UGS: Invert the options in the 'Show Changes' submenu for simplicity.

Change 3833528 by Ben.Marsh

	UAT: Script to rewrite source files with public include paths relative to the 'Public' folder. Usage is: RebasePublicIncludePaths -UpdateDir=<Dir> [-Project=<Dir>] [-Write].

Change 3833543 by Ben.Marsh

	UBT: Allow targets to opt-out of having public include paths added for every dependent module. This reduces the command line length when building a target, which has recently become a problem with larger games (due to Microsoft's compiler embedding the command line into each object file, with a maximum length of 64kb). All engine modules are compiled with this enabled; games may opt into it by setting bLegacyPublicIncludePaths = false; from their .target.cs, as may individual modules.

Change 3834354 by Robert.Manuszewski

	Archetype pointer will now be cached to avoid locking the object tables when acquiring its info. It should also be faster this way regardless of any locks.

	#jira UE-52035

Change 3834400 by Robert.Manuszewski

	Fixing crash on exit caused by cached archetypes not being cleaned up before static exit cleanup.

	#jira UE-52035

Change 3834947 by Steve.Robb

	USE_FORMAT_STRING_TYPE_CHECKING removed from FMsg::Logf and FMsg::Logf_Internal.

Change 3835004 by Ben.Marsh

	Fix code that relies on dubious behavior of requiring referenced "include path only" modules having their _API macros set to be empty, even if the module is actually implemented in a separate DLL.

Change 3835340 by Ben.Marsh

	Fix errors making installed build from directories with spaces in the name.

Change 3835972 by Ben.Marsh

	UBT: Improved diagnostic message for targets which don't need a version file.

Change 3836019 by Ben.Marsh

	UBT: Fix warnings caused by defining linkage macros for third party libraries.

Change 3836269 by Ben.Marsh

	Fix message box larger than the screen height being created when a large number of modules are incompatible on startup.

Change 3836543 by Ben.Marsh

	Enable SoundMod plugin on Linux, since it's already supported through the editor.

Change 3836546 by Ben.Marsh

	PR #4412: fix type mismatch (Contributed by nakapon)


Change 3836805 by Ben.Marsh

	Fix commandlet to compile marketplace plugins.

Change 3836829 by Ben.Marsh

	UBT: Fix ability to precompile plugins from installed engine builds.

Change 3837036 by Ben.Marsh

	UBT: Write the previous and new contents of intermediate files to the log if they change. Makes it easier to debug unexpected rebuilds.

Change 3837037 by Ben.Marsh

	UBT: Fix engine modules having inconsistent definitions depending on whether modules are only referenced for their include paths vs being linked into a binary (due to different _API macro).

Change 3837040 by Ben.Marsh

	UBT: Remove code that initializes members in ModuleRules and TargetRules objects before the constructor is run. This is no longer necessary, now that the backwards-compatible default constructors have been removed.

Change 3837247 by Ben.Marsh

	UBT: Remove UELinkerFixups module, now that plugins and precompiled modules do not require hacks to force initialization (since they're linked in as object files).

	Encryption and signing keys are now set via macros expanded from the IMPLEMENT_PRIMARY_GAME_MODULE macro, via project-specific macros added in the TargetRules constructor.

Change 3837262 by Ben.Marsh

	UBT: Set whether a module is an engine module or not via a default value for the rules assembly. All non-program engine and enterprise modules are created with this flag set to true; program targets and modules are now created from a different assembly that sets it to false. This removes hacks from UEBuildModule needed to adjust behavior for different module types based on the directory containing the module.

	Also add a bUseBackwardsCompatibleDefaults flag to the TargetRules class, also initialized to a default value from a setting passed to the RulesAssembly constructor. This controls whether modules created for the target should be configured to allow breaking changes to default settings, and is set to false for all engine targets, and true for all project targets.

Change 3837343 by Ben.Marsh

	UBT: Remove the OverrideExecutableFileExtension target property. Change the only current use for this (the MayaLiveLinkPlugin target) to use a post build step to copy the file instead.

Change 3837356 by Ben.Marsh

	Fix invalid character encodings.

Change 3837727 by Graeme.Thornton

	UnrealPak: KeyGenerator: Only generate prime table when required, not all the time

Change 3837823 by Ben.Marsh

	UBT: Output warnings and errors when compiling module rules assembly in a way that allows them to be double-clicked in the Visual Studio output window.

Change 3837831 by Graeme.Thornton

	UBT: When parsing crypto settings, always load legacy data first, then allow the new system to override it. Provides the same key backwards compatibility that the editor settings class gives

Change 3837857 by Robert.Manuszewski

	PR #4404: Make FGCArrayPool singleton global instead of per-CU (Contributed by mhutch)


Change 3837943 by Robert.Manuszewski

	PR #4405: Fix FGarbageCollectionTracer (Contributed by mhutch)


Change 3838451 by Ben.Marsh

	UBT: Fix exceptions thrown on a background thread while caching C++ includes not being caught and logged correctly. Now captures exceptions and re-throws on the main thread.

	#jira UE-53996

Change 3839519 by Ben.Marsh

	UBT: Simplify configuring bPrecompile and bUsePrecompile settings for modules. Each rules assembly can now be configured as installed, which defaults the module rules it creates to use precompiled data.

Change 3843790 by Graeme.Thornton

	UnrealPak: Log the size of all encrypted data

Change 3844258 by Ben.Marsh

	Fix plugin compile failure when created via new plugin wizard. Passing -plugin on the command line is unnecessary, and is now reserved for packaging external plugins for the marketplace.

	Also extend the length of time that the error toast stays visible, and don't delete the plugin on failure.

	#jira UE-54157

Change 3845796 by Ben.Marsh

	Workaround for slow performance of String.EndsWith() on Mono.

Change 3845823 by Ben.Marsh

	Fix case sensitive matching of platform names in -TargetPlatform=X argument to BuildCookRun.

	#jira UE-54123

Change 3845901 by Arciel.Rekman

	Linux: fix crash due to lambda lifetime issues (UE-54040).

	- The lambda goes out of scope in FBufferVisualizationMenuCommands::CreateVisualizationCommands, crashing the editor if compiled with a recent clang (5.0+).

	(Edigrating 3819174 to Dev-Core)

Change 3846439 by Ben.Marsh

	Revert CL 3822742 to always call Process.WaitForExit(). The Android target platform module in the editor spawns ADB.EXE, which inherits the editor's stdout/stderr handles and forks itself. Process.WaitForExit() waits for EOF on those pipes, which never occurs because the forked process never terminates.

	Proper fix is probably to have the engine explicitly duplicate stdout/stderr handles for new pipes to output process, but too risky before copying up to Main.

Change 3816608 by Ben.Marsh

	UBT: Use DirectoryReference objects for all include paths.

Change 3816954 by Ben.Marsh

	UBT: Remove bIncludeDependentLibrariesInLibrary option. This is not widely supported by platform toolchains, and is not used anywhere.

Change 3816986 by Ben.Marsh

	UBT: Remove UEBuildBinaryConfig; UEBuildBinary objects are now just created directly.

Change 3816991 by Ben.Marsh

	UBT: Deprecate PlatformSpecificDynamicallyLoadedModules. We no longer have any special behavior for these modules.

Change 3823090 by Ben.Marsh

	UAT: Improve logging for child UAT instances.

	- Calling RunUAT now requires an identifier for prefixing into the parent log, which is also used to determine the name of the log folder.
	- Stdout is no longer written to its own output file, since it's written to the parent stdout, the parent log file, and the child log file anyway.
	- Log folders for child UAT instances are left intact, rather than being copied to the parent folder. The derived names for the copied names were confusing and hard to read.
	- Output from UAT is no longer returned as a string. It should not be parsed anyway (but may be huge!). ProcessResult now supports running without capturing output.

Change 3826082 by Ben.Marsh

	UBT: Add a check to make sure that all modules that are precompiled are correctly marked to enable it, even if they are part of the build target.

Change 3827025 by Ben.Marsh

	UBT: Move the compile output directory into a property on the module, and explicitly pass it to the toolchain when compiling.

Change 3829927 by James.Hopkin

	Made HTTP interface const correct

Change 3833533 by Ben.Marsh

	Rewrite engine source files to base include paths relative to the "Public" directory. This allows reducing the number of public include paths that have to be added for engine modules.

Change 3835826 by Ben.Marsh

	UBT: Precompiled targets now generate a separate manifest for each precompiled module, rather than adding object files to a library. This fixes issues where object files from static libraries would not be linked into a target if a symbol in them was not referenced.

Change 3835969 by Ben.Marsh

	UBT: Fix cases where text is being written directly to the console rather than via logging functions.

Change 3837777 by Steve.Robb

	Format string type checking added to FOutputDevice::Logf.
	Fixes for those.

Change 3838569 by Steve.Robb

	Algo moved up a folder.

[CL 3847482 by Ben Marsh in Main branch]
2018-01-20 11:19:29 -05:00

1282 lines
40 KiB
C++
Raw Blame History

// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#include "STextPropertyEditableTextBox.h"
#include "Internationalization/TextNamespaceUtil.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/Layout/SBox.h"
#include "Widgets/Layout/SGridPanel.h"
#include "Widgets/Layout/SUniformGridPanel.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/SMultiLineEditableTextBox.h"
#include "Widgets/Input/SEditableTextBox.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Input/SComboBox.h"
#include "Widgets/Input/SCheckBox.h"
#include "EditorStyleSet.h"
#include "Misc/PackageName.h"
#include "AssetRegistryModule.h"
#include "Internationalization/StringTable.h"
#include "Internationalization/TextPackageNamespaceUtil.h"
#include "Internationalization/StringTableCore.h"
#include "Internationalization/StringTableRegistry.h"
#include "Serialization/TextReferenceCollector.h"
#define LOCTEXT_NAMESPACE "STextPropertyEditableTextBox"
FText STextPropertyEditableTextBox::MultipleValuesText(NSLOCTEXT("PropertyEditor", "MultipleValues", "Multiple Values"));
#if USE_STABLE_LOCALIZATION_KEYS
void IEditableTextProperty::StaticStableTextId(UObject* InObject, const ETextPropertyEditAction InEditAction, const FString& InTextSource, const FString& InProposedNamespace, const FString& InProposedKey, FString& OutStableNamespace, FString& OutStableKey)
{
UPackage* Package = InObject ? InObject->GetOutermost() : nullptr;
StaticStableTextId(Package, InEditAction, InTextSource, InProposedNamespace, InProposedKey, OutStableNamespace, OutStableKey);
}
void IEditableTextProperty::StaticStableTextId(UPackage* InPackage, const ETextPropertyEditAction InEditAction, const FString& InTextSource, const FString& InProposedNamespace, const FString& InProposedKey, FString& OutStableNamespace, FString& OutStableKey)
{
bool bPersistKey = false;
const FString PackageNamespace = TextNamespaceUtil::EnsurePackageNamespace(InPackage);
if (!PackageNamespace.IsEmpty())
{
// Make sure the proposed namespace is using the correct namespace for this package
OutStableNamespace = TextNamespaceUtil::BuildFullNamespace(InProposedNamespace, PackageNamespace, /*bAlwaysApplyPackageNamespace*/true);
if (InProposedNamespace.Equals(OutStableNamespace, ESearchCase::CaseSensitive) || InEditAction == ETextPropertyEditAction::EditedNamespace)
{
// If the proposal was already using the correct namespace (or we just set the namespace), attempt to persist the proposed key too
if (!InProposedKey.IsEmpty())
{
// If we changed the source text, then we can persist the key if this text is the *only* reference using that ID
// If we changed the identifier, then we can persist the key only if doing so won't cause an identify conflict
const FTextReferenceCollector::EComparisonMode ReferenceComparisonMode = InEditAction == ETextPropertyEditAction::EditedSource ? FTextReferenceCollector::EComparisonMode::MatchId : FTextReferenceCollector::EComparisonMode::MismatchSource;
const int32 RequiredReferenceCount = InEditAction == ETextPropertyEditAction::EditedSource ? 1 : 0;
int32 ReferenceCount = 0;
FTextReferenceCollector(InPackage, ReferenceComparisonMode, OutStableNamespace, InProposedKey, InTextSource, ReferenceCount);
if (ReferenceCount == RequiredReferenceCount)
{
bPersistKey = true;
OutStableKey = InProposedKey;
}
}
}
else if (InEditAction != ETextPropertyEditAction::EditedNamespace)
{
// If our proposed namespace wasn't correct for our package, and we didn't just set it (which doesn't include the package namespace)
// then we should clear out any user specified part of it
OutStableNamespace = TextNamespaceUtil::BuildFullNamespace(FString(), PackageNamespace, /*bAlwaysApplyPackageNamespace*/true);
}
}
if (!bPersistKey)
{
OutStableKey = FGuid::NewGuid().ToString();
}
}
#endif // USE_STABLE_LOCALIZATION_KEYS
void STextPropertyEditableStringTableReference::Construct(const FArguments& InArgs, const TSharedRef<IEditableTextProperty>& InEditableTextProperty)
{
EditableTextProperty = InEditableTextProperty;
TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
HorizontalBox->AddSlot()
[
SAssignNew(StringTableCombo, SComboBox<TSharedPtr<FAvailableStringTable>>)
.ComboBoxStyle(InArgs._ComboStyle)
.OptionsSource(&StringTableComboOptions)
.OnGenerateWidget(this, &STextPropertyEditableStringTableReference::MakeStringTableComboWidget)
.OnSelectionChanged(this, &STextPropertyEditableStringTableReference::OnStringTableComboChanged)
.OnComboBoxOpening(this, &STextPropertyEditableStringTableReference::OnStringTableComboOpening)
.Content()
[
SNew(STextBlock)
.Text(this, &STextPropertyEditableStringTableReference::GetStringTableComboContent)
.ToolTipText(this, &STextPropertyEditableStringTableReference::GetStringTableComboToolTip)
]
];
HorizontalBox->AddSlot()
[
SAssignNew(KeyCombo, SComboBox<TSharedPtr<FString>>)
.ComboBoxStyle(InArgs._ComboStyle)
.OptionsSource(&KeyComboOptions)
.OnGenerateWidget(this, &STextPropertyEditableStringTableReference::MakeKeyComboWidget)
.OnSelectionChanged(this, &STextPropertyEditableStringTableReference::OnKeyComboChanged)
.OnComboBoxOpening(this, &STextPropertyEditableStringTableReference::OnKeyComboOpening)
.Content()
[
SNew(STextBlock)
.Text(this, &STextPropertyEditableStringTableReference::GetKeyComboContent)
.ToolTipText(this, &STextPropertyEditableStringTableReference::GetKeyComboToolTip)
]
];
if (InArgs._AllowUnlink)
{
HorizontalBox->AddSlot()
.AutoWidth()
[
SNew(SButton)
.ButtonStyle(InArgs._ButtonStyle)
.Text(LOCTEXT("UnlinkStringTable", "Unlink"))
.IsEnabled(this, &STextPropertyEditableStringTableReference::IsUnlinkEnabled)
.OnClicked(this, &STextPropertyEditableStringTableReference::OnUnlinkClicked)
];
}
ChildSlot
[
HorizontalBox
];
}
void STextPropertyEditableStringTableReference::GetTableIdAndKey(FName& OutTableId, FString& OutKey) const
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts > 0)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
FStringTableRegistry::Get().FindTableIdAndKey(PropertyValue, OutTableId, OutKey);
// Verify that all texts are using the same string table and key
for (int32 TextIndex = 1; TextIndex < NumTexts; ++TextIndex)
{
FName TmpTableId;
FString TmpKey;
if (FStringTableRegistry::Get().FindTableIdAndKey(PropertyValue, TmpTableId, TmpKey) && OutTableId == TmpTableId)
{
if (!OutKey.Equals(TmpKey, ESearchCase::CaseSensitive))
{
// Not using the same key - clear the key but keep the table and keep enumerating to verify the table on the remaining texts
OutKey.Reset();
}
}
else
{
// Not using a string table, or using a different string table - clear both table ID and key
OutTableId = FName();
OutKey.Reset();
break;
}
}
}
}
void STextPropertyEditableStringTableReference::SetTableIdAndKey(const FName InTableId, const FString& InKey)
{
const FText TextToSet = FText::FromStringTable(InTableId, InKey);
if (TextToSet.IsFromStringTable())
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
EditableTextProperty->SetText(TextIndex, TextToSet);
}
}
}
TSharedRef<SWidget> STextPropertyEditableStringTableReference::MakeStringTableComboWidget(TSharedPtr<FAvailableStringTable> InItem)
{
return SNew(STextBlock)
.Text(InItem->DisplayName)
.ToolTipText(FText::FromName(InItem->TableId));
}
void STextPropertyEditableStringTableReference::OnStringTableComboChanged(TSharedPtr<FAvailableStringTable> NewSelection, ESelectInfo::Type SelectInfo)
{
// If it's set from code, we did that on purpose
if (SelectInfo != ESelectInfo::Direct && NewSelection.IsValid())
{
// Make sure any selected string table asset is loaded
FName TableId = NewSelection->TableId;
IStringTableEngineBridge::RedirectAndLoadStringTableAsset(TableId, EStringTableLoadingPolicy::FindOrFullyLoad);
FStringTableConstPtr StringTable = FStringTableRegistry::Get().FindStringTable(TableId);
if (StringTable.IsValid())
{
// Just use the first key when changing the string table
StringTable->EnumerateSourceStrings([&](const FString& InKey, const FString& InSourceString) -> bool
{
SetTableIdAndKey(TableId, InKey);
return false; // stop enumeration
});
}
}
}
void STextPropertyEditableStringTableReference::OnStringTableComboOpening()
{
FName CurrentTableId;
{
FString TmpKey;
GetTableIdAndKey(CurrentTableId, TmpKey);
}
TSharedPtr<FAvailableStringTable> SelectedStringTableComboEntry;
StringTableComboOptions.Reset();
// Process assets first (as they may currently be unloaded)
{
FAssetRegistryModule& AssetRegistryModule = FModuleManager::Get().LoadModuleChecked<FAssetRegistryModule>(AssetRegistryConstants::ModuleName);
TArray<FAssetData> StringTableAssets;
AssetRegistryModule.Get().GetAssetsByClass(UStringTable::StaticClass()->GetFName(), StringTableAssets);
for (const FAssetData& StringTableAsset : StringTableAssets)
{
TSharedRef<FAvailableStringTable> AvailableStringTableEntry = MakeShared<FAvailableStringTable>();
AvailableStringTableEntry->TableId = StringTableAsset.ObjectPath;
AvailableStringTableEntry->DisplayName = FText::FromName(StringTableAsset.AssetName);
if (StringTableAsset.ObjectPath == CurrentTableId)
{
SelectedStringTableComboEntry = AvailableStringTableEntry;
}
StringTableComboOptions.Add(AvailableStringTableEntry);
}
}
// Process the remaining non-asset string tables now
FStringTableRegistry::Get().EnumerateStringTables([&](const FName& InTableId, const FStringTableConstRef& InStringTable) -> bool
{
const bool bAlreadyAdded = StringTableComboOptions.ContainsByPredicate([InTableId](const TSharedPtr<FAvailableStringTable>& InAvailableStringTable)
{
return InAvailableStringTable->TableId == InTableId;
});
if (!bAlreadyAdded)
{
TSharedRef<FAvailableStringTable> AvailableStringTableEntry = MakeShared<FAvailableStringTable>();
AvailableStringTableEntry->TableId = InTableId;
AvailableStringTableEntry->DisplayName = FText::FromName(InTableId);
if (InTableId == CurrentTableId)
{
SelectedStringTableComboEntry = AvailableStringTableEntry;
}
StringTableComboOptions.Add(AvailableStringTableEntry);
}
return true; // continue enumeration
});
StringTableComboOptions.Sort([](const TSharedPtr<FAvailableStringTable>& InOne, const TSharedPtr<FAvailableStringTable>& InTwo)
{
return InOne->DisplayName.ToString() < InTwo->DisplayName.ToString();
});
if (SelectedStringTableComboEntry.IsValid())
{
StringTableCombo->SetSelectedItem(SelectedStringTableComboEntry);
}
else
{
StringTableCombo->ClearSelection();
}
}
FText STextPropertyEditableStringTableReference::GetStringTableComboContent() const
{
FName CurrentTableId;
{
FString TmpKey;
GetTableIdAndKey(CurrentTableId, TmpKey);
}
return FText::FromString(FPackageName::GetLongPackageAssetName(CurrentTableId.ToString()));
}
FText STextPropertyEditableStringTableReference::GetStringTableComboToolTip() const
{
FName CurrentTableId;
{
FString TmpKey;
GetTableIdAndKey(CurrentTableId, TmpKey);
}
return FText::FromName(CurrentTableId);
}
TSharedRef<SWidget> STextPropertyEditableStringTableReference::MakeKeyComboWidget(TSharedPtr<FString> InItem)
{
return SNew(STextBlock)
.Text(FText::FromString(*InItem))
.ToolTipText(FText::FromString(*InItem));
}
void STextPropertyEditableStringTableReference::OnKeyComboChanged(TSharedPtr<FString> NewSelection, ESelectInfo::Type SelectInfo)
{
// If it's set from code, we did that on purpose
if (SelectInfo != ESelectInfo::Direct && NewSelection.IsValid())
{
FName CurrentTableId;
{
FString TmpKey;
GetTableIdAndKey(CurrentTableId, TmpKey);
}
SetTableIdAndKey(CurrentTableId, *NewSelection);
}
}
void STextPropertyEditableStringTableReference::OnKeyComboOpening()
{
FName CurrentTableId;
FString CurrentKey;
GetTableIdAndKey(CurrentTableId, CurrentKey);
TSharedPtr<FString> SelectedKeyComboEntry;
KeyComboOptions.Reset();
if (!CurrentTableId.IsNone())
{
FStringTableConstPtr StringTable = FStringTableRegistry::Get().FindStringTable(CurrentTableId);
if (StringTable.IsValid())
{
StringTable->EnumerateSourceStrings([&](const FString& InKey, const FString& InSourceString) -> bool
{
TSharedRef<FString> KeyComboEntry = MakeShared<FString>(InKey);
if (InKey.Equals(CurrentKey, ESearchCase::CaseSensitive))
{
SelectedKeyComboEntry = KeyComboEntry;
}
KeyComboOptions.Add(KeyComboEntry);
return true; // continue enumeration
});
}
}
KeyComboOptions.Sort([](const TSharedPtr<FString>& InOne, const TSharedPtr<FString>& InTwo)
{
return *InOne < *InTwo;
});
if (SelectedKeyComboEntry.IsValid())
{
KeyCombo->SetSelectedItem(SelectedKeyComboEntry);
}
else
{
KeyCombo->ClearSelection();
}
}
FText STextPropertyEditableStringTableReference::GetKeyComboContent() const
{
FString CurrentKey;
{
FName TmpTableId;
GetTableIdAndKey(TmpTableId, CurrentKey);
}
return FText::FromString(MoveTemp(CurrentKey));
}
FText STextPropertyEditableStringTableReference::GetKeyComboToolTip() const
{
return GetKeyComboContent();
}
bool STextPropertyEditableStringTableReference::IsUnlinkEnabled() const
{
bool bEnabled = false;
const int32 NumTexts = EditableTextProperty->GetNumTexts();
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText CurrentText = EditableTextProperty->GetText(TextIndex);
if (CurrentText.IsFromStringTable())
{
bEnabled = true;
break;
}
}
return bEnabled;
}
FReply STextPropertyEditableStringTableReference::OnUnlinkClicked()
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText CurrentText = EditableTextProperty->GetText(TextIndex);
if (CurrentText.IsFromStringTable())
{
EditableTextProperty->SetText(TextIndex, FText::GetEmpty());
}
}
return FReply::Handled();
}
void STextPropertyEditableTextBox::Construct(const FArguments& InArgs, const TSharedRef<IEditableTextProperty>& InEditableTextProperty)
{
EditableTextProperty = InEditableTextProperty;
TSharedPtr<SHorizontalBox> HorizontalBox;
const bool bIsPassword = EditableTextProperty->IsPassword();
bIsMultiLine = EditableTextProperty->IsMultiLineText();
if (bIsMultiLine)
{
ChildSlot
[
SAssignNew(HorizontalBox, SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(SBox)
.MinDesiredWidth(InArgs._MinDesiredWidth)
.MaxDesiredHeight(InArgs._MaxDesiredHeight)
[
SAssignNew(MultiLineWidget, SMultiLineEditableTextBox)
.Text(this, &STextPropertyEditableTextBox::GetTextValue)
.ToolTipText(this, &STextPropertyEditableTextBox::GetToolTipText)
.Style(InArgs._Style)
.Font(InArgs._Font)
.ForegroundColor(InArgs._ForegroundColor)
.SelectAllTextWhenFocused(false)
.ClearKeyboardFocusOnCommit(false)
.OnTextChanged(this, &STextPropertyEditableTextBox::OnTextChanged)
.OnTextCommitted(this, &STextPropertyEditableTextBox::OnTextCommitted)
.SelectAllTextOnCommit(false)
.IsReadOnly(this, &STextPropertyEditableTextBox::IsSourceTextReadOnly)
.AutoWrapText(InArgs._AutoWrapText)
.WrapTextAt(InArgs._WrapTextAt)
.ModiferKeyForNewLine(EModifierKey::Shift)
//.IsPassword(bIsPassword)
]
]
];
PrimaryWidget = MultiLineWidget;
}
else
{
ChildSlot
[
SAssignNew(HorizontalBox, SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(SBox)
.MinDesiredWidth(InArgs._MinDesiredWidth)
[
SAssignNew(SingleLineWidget, SEditableTextBox)
.Text(this, &STextPropertyEditableTextBox::GetTextValue)
.ToolTipText(this, &STextPropertyEditableTextBox::GetToolTipText)
.Style(InArgs._Style)
.Font(InArgs._Font)
.ForegroundColor(InArgs._ForegroundColor)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false)
.OnTextChanged(this, &STextPropertyEditableTextBox::OnTextChanged)
.OnTextCommitted(this, &STextPropertyEditableTextBox::OnTextCommitted)
.SelectAllTextOnCommit(true)
.IsReadOnly(this, &STextPropertyEditableTextBox::IsSourceTextReadOnly)
.IsPassword(bIsPassword)
]
]
];
PrimaryWidget = SingleLineWidget;
}
HorizontalBox->AddSlot()
.AutoWidth()
[
SNew(SComboButton)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.ContentPadding(FMargin(4, 0))
.ButtonStyle(FEditorStyle::Get(), "HoverHintOnly")
.ForegroundColor(FSlateColor::UseForeground())
.ToolTipText(LOCTEXT("AdvancedTextSettingsComboToolTip", "Edit advanced text settings."))
.MenuContent()
[
SNew(SBox)
.WidthOverride(340)
.Padding(4)
[
SNew(SGridPanel)
.FillColumn(1, 1.0f)
// Inline Text
+SGridPanel::Slot(0, 0)
.ColumnSpan(2)
.Padding(2)
.HAlign(HAlign_Left)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.TextStyle(FEditorStyle::Get(), "LargeText")
.Text(LOCTEXT("TextInlineTextLabel", "Inline Text"))
]
// Localizable?
+SGridPanel::Slot(0, 1)
.Padding(2)
.HAlign(HAlign_Right)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text(LOCTEXT("TextLocalizableLabel", "Localizable:"))
]
+SGridPanel::Slot(1, 1)
.Padding(2)
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.Padding(0)
[
SNew(SUniformGridPanel)
.SlotPadding(FMargin(0, 0, 4, 0))
+SUniformGridPanel::Slot(0, 0)
[
SNew(SCheckBox)
.Style(FEditorStyle::Get(), "ToggleButtonCheckbox")
.ToolTipText(LOCTEXT("TextLocalizableToggleYesToolTip", "Assign this text a key and allow it to be gathered for localization."))
.Padding(FMargin(4, 2))
.HAlign(HAlign_Center)
.IsEnabled(this, &STextPropertyEditableTextBox::IsCultureInvariantFlagEnabled)
.IsChecked(this, &STextPropertyEditableTextBox::GetLocalizableCheckState, true/*bActiveState*/)
.OnCheckStateChanged(this, &STextPropertyEditableTextBox::HandleLocalizableCheckStateChanged, true/*bActiveState*/)
[
SNew(STextBlock)
.Text(LOCTEXT("TextLocalizableToggleYes", "Yes"))
]
]
+SUniformGridPanel::Slot(1, 0)
[
SNew(SCheckBox)
.Style(FEditorStyle::Get(), "ToggleButtonCheckbox")
.ToolTipText(LOCTEXT("TextLocalizableToggleNoToolTip", "Mark this text as 'culture invariant' to prevent it being gathered for localization."))
.Padding(FMargin(4, 2))
.HAlign(HAlign_Center)
.IsEnabled(this, &STextPropertyEditableTextBox::IsCultureInvariantFlagEnabled)
.IsChecked(this, &STextPropertyEditableTextBox::GetLocalizableCheckState, false/*bActiveState*/)
.OnCheckStateChanged(this, &STextPropertyEditableTextBox::HandleLocalizableCheckStateChanged, false/*bActiveState*/)
[
SNew(STextBlock)
.Text(LOCTEXT("TextLocalizableToggleNo", "No"))
]
]
]
]
#if USE_STABLE_LOCALIZATION_KEYS
// Package
+SGridPanel::Slot(0, 2)
.Padding(2)
.HAlign(HAlign_Right)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text(LOCTEXT("TextPackageLabel", "Package:"))
]
+SGridPanel::Slot(1, 2)
.Padding(2)
[
SNew(SEditableTextBox)
.Text(this, &STextPropertyEditableTextBox::GetPackageValue)
.IsReadOnly(true)
]
#endif // USE_STABLE_LOCALIZATION_KEYS
// Namespace
+SGridPanel::Slot(0, 3)
.Padding(2)
.HAlign(HAlign_Right)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text(LOCTEXT("TextNamespaceLabel", "Namespace:"))
]
+SGridPanel::Slot(1, 3)
.Padding(2)
[
SAssignNew(NamespaceEditableTextBox, SEditableTextBox)
.Text(this, &STextPropertyEditableTextBox::GetNamespaceValue)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false)
.OnTextChanged(this, &STextPropertyEditableTextBox::OnNamespaceChanged)
.OnTextCommitted(this, &STextPropertyEditableTextBox::OnNamespaceCommitted)
.SelectAllTextOnCommit(true)
.IsReadOnly(this, &STextPropertyEditableTextBox::IsIdentityReadOnly)
]
// Key
+SGridPanel::Slot(0, 4)
.Padding(2)
.HAlign(HAlign_Right)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text(LOCTEXT("TextKeyLabel", "Key:"))
]
+SGridPanel::Slot(1, 4)
.Padding(2)
[
SAssignNew(KeyEditableTextBox, SEditableTextBox)
.Text(this, &STextPropertyEditableTextBox::GetKeyValue)
#if USE_STABLE_LOCALIZATION_KEYS
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false)
.OnTextChanged(this, &STextPropertyEditableTextBox::OnKeyChanged)
.OnTextCommitted(this, &STextPropertyEditableTextBox::OnKeyCommitted)
.SelectAllTextOnCommit(true)
.IsReadOnly(this, &STextPropertyEditableTextBox::IsIdentityReadOnly)
#else // USE_STABLE_LOCALIZATION_KEYS
.IsReadOnly(true)
#endif // USE_STABLE_LOCALIZATION_KEYS
]
// Referenced Text
+SGridPanel::Slot(0, 5)
.ColumnSpan(2)
.Padding(2)
.HAlign(HAlign_Left)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.TextStyle(FEditorStyle::Get(), "LargeText")
.Text(LOCTEXT("TextReferencedTextLabel", "Referenced Text"))
]
// String Table
+SGridPanel::Slot(0, 6)
.Padding(2)
.HAlign(HAlign_Right)
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text(LOCTEXT("TextStringTableLabel", "String Table:"))
]
+SGridPanel::Slot(1, 6)
.Padding(2)
[
SNew(STextPropertyEditableStringTableReference, InEditableTextProperty)
.AllowUnlink(true)
.IsEnabled(this, &STextPropertyEditableTextBox::CanEdit)
]
]
]
];
HorizontalBox->AddSlot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.AutoWidth()
[
SNew(SImage)
.Image(FCoreStyle::Get().GetBrush("Icons.Warning"))
.Visibility(this, &STextPropertyEditableTextBox::GetTextWarningImageVisibility)
.ToolTipText(LOCTEXT("TextNotLocalizedWarningToolTip", "This text is marked as 'culture invariant' and won't be gathered for localization.\nYou can change this by editing the advanced text settings."))
];
SetEnabled(TAttribute<bool>(this, &STextPropertyEditableTextBox::CanEdit));
}
void STextPropertyEditableTextBox::GetDesiredWidth(float& OutMinDesiredWidth, float& OutMaxDesiredWidth)
{
if (bIsMultiLine)
{
OutMinDesiredWidth = 250.0f;
}
else
{
OutMinDesiredWidth = 125.0f;
}
OutMaxDesiredWidth = 600.0f;
}
bool STextPropertyEditableTextBox::SupportsKeyboardFocus() const
{
return PrimaryWidget.IsValid() && PrimaryWidget->SupportsKeyboardFocus();
}
FReply STextPropertyEditableTextBox::OnFocusReceived(const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent)
{
// Forward keyboard focus to our editable text widget
return FReply::Handled().SetUserFocus(PrimaryWidget.ToSharedRef(), InFocusEvent.GetCause());
}
void STextPropertyEditableTextBox::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
const float CurrentHeight = AllottedGeometry.GetLocalSize().Y;
if (bIsMultiLine && PreviousHeight.IsSet() && PreviousHeight.GetValue() != CurrentHeight)
{
EditableTextProperty->RequestRefresh();
}
PreviousHeight = CurrentHeight;
}
bool STextPropertyEditableTextBox::CanEdit() const
{
const bool bIsReadOnly = FTextLocalizationManager::Get().IsLocalizationLocked() || EditableTextProperty->IsReadOnly();
return !bIsReadOnly;
}
bool STextPropertyEditableTextBox::IsCultureInvariantFlagEnabled() const
{
return !IsSourceTextReadOnly();
}
bool STextPropertyEditableTextBox::IsSourceTextReadOnly() const
{
if (!CanEdit())
{
return true;
}
// We can't edit the source string of string table references
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText TextValue = EditableTextProperty->GetText(0);
if (TextValue.IsFromStringTable())
{
return true;
}
}
return false;
}
bool STextPropertyEditableTextBox::IsIdentityReadOnly() const
{
if (!CanEdit())
{
return true;
}
// We can't edit the identity of texts that don't gather for localization
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText TextValue = EditableTextProperty->GetText(0);
if (!TextValue.ShouldGatherForLocalization())
{
return true;
}
}
return false;
}
FText STextPropertyEditableTextBox::GetToolTipText() const
{
FText LocalizedTextToolTip;
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText TextValue = EditableTextProperty->GetText(0);
if (TextValue.IsFromStringTable())
{
FName TableId;
FString Key;
FStringTableRegistry::Get().FindTableIdAndKey(TextValue, TableId, Key);
LocalizedTextToolTip = FText::Format(
LOCTEXT("StringTableTextToolTipFmt", "--- String Table Reference ---\nTable ID: {0}\nKey: {1}"),
FText::FromName(TableId), FText::FromString(Key)
);
}
else
{
bool bIsLocalized = false;
FString Namespace;
FString Key;
const FString* SourceString = FTextInspector::GetSourceString(TextValue);
if (SourceString && TextValue.ShouldGatherForLocalization())
{
bIsLocalized = FTextLocalizationManager::Get().FindNamespaceAndKeyFromDisplayString(FTextInspector::GetSharedDisplayString(TextValue), Namespace, Key);
}
if (bIsLocalized)
{
const FString PackageNamespace = TextNamespaceUtil::ExtractPackageNamespace(Namespace);
const FString TextNamespace = TextNamespaceUtil::StripPackageNamespace(Namespace);
LocalizedTextToolTip = FText::Format(
LOCTEXT("LocalizedTextToolTipFmt", "--- Localized Text ---\nPackage: {0}\nNamespace: {1}\nKey: {2}\nSource: {3}"),
FText::FromString(PackageNamespace), FText::FromString(TextNamespace), FText::FromString(Key), FText::FromString(*SourceString)
);
}
}
}
FText BaseToolTipText = EditableTextProperty->GetToolTipText();
if (FTextLocalizationManager::Get().IsLocalizationLocked())
{
const FText LockdownToolTip = FTextLocalizationManager::Get().IsGameLocalizationPreviewEnabled()
? LOCTEXT("LockdownToolTip_Preview", "Localization is locked down due to the active game localization preview")
: LOCTEXT("LockdownToolTip_Other", "Localization is locked down");
BaseToolTipText = BaseToolTipText.IsEmptyOrWhitespace() ? LockdownToolTip : FText::Format(LOCTEXT("ToolTipLockdownFmt", "!!! {0} !!!\n\n{1}"), LockdownToolTip, BaseToolTipText);
}
if (LocalizedTextToolTip.IsEmptyOrWhitespace())
{
return BaseToolTipText;
}
if (BaseToolTipText.IsEmptyOrWhitespace())
{
return LocalizedTextToolTip;
}
return FText::Format(LOCTEXT("ToolTipCompleteFmt", "{0}\n\n{1}"), BaseToolTipText, LocalizedTextToolTip);
}
FText STextPropertyEditableTextBox::GetTextValue() const
{
FText TextValue;
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
TextValue = EditableTextProperty->GetText(0);
}
else if (NumTexts > 1)
{
TextValue = MultipleValuesText;
}
return TextValue;
}
void STextPropertyEditableTextBox::OnTextChanged(const FText& NewText)
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
FText TextErrorMsg;
// Don't validate the Multiple Values text if there are multiple properties being set
if (NumTexts > 0 && (NumTexts == 1 || NewText.ToString().Equals(MultipleValuesText.ToString(), ESearchCase::CaseSensitive)))
{
EditableTextProperty->IsValidText(NewText, TextErrorMsg);
}
// Update or clear the error message
SetTextError(TextErrorMsg);
}
void STextPropertyEditableTextBox::OnTextCommitted(const FText& NewText, ETextCommit::Type CommitInfo)
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
// Don't commit the Multiple Values text if there are multiple properties being set
if (NumTexts > 0 && (NumTexts == 1 || !NewText.ToString().Equals(MultipleValuesText.ToString(), ESearchCase::CaseSensitive)))
{
FText TextErrorMsg;
if (EditableTextProperty->IsValidText(NewText, TextErrorMsg))
{
// Valid text; clear any error
SetTextError(FText::GetEmpty());
}
else
{
// Invalid text; set the error and prevent the new text from being set
SetTextError(TextErrorMsg);
return;
}
const FString& SourceString = NewText.ToString();
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText PropertyValue = EditableTextProperty->GetText(TextIndex);
// Only apply the change if the new text is different
if (PropertyValue.ToString().Equals(NewText.ToString(), ESearchCase::CaseSensitive))
{
continue;
}
// Is the new text is empty, just use the empty instance
if (NewText.IsEmpty())
{
EditableTextProperty->SetText(TextIndex, FText::GetEmpty());
continue;
}
// Maintain culture invariance when editing the text
if (PropertyValue.IsCultureInvariant())
{
EditableTextProperty->SetText(TextIndex, FText::AsCultureInvariant(NewText.ToString()));
continue;
}
FString NewNamespace;
FString NewKey;
#if USE_STABLE_LOCALIZATION_KEYS
{
// Get the stable namespace and key that we should use for this property
const FString* TextSource = FTextInspector::GetSourceString(PropertyValue);
EditableTextProperty->GetStableTextId(
TextIndex,
IEditableTextProperty::ETextPropertyEditAction::EditedSource,
TextSource ? *TextSource : FString(),
FTextInspector::GetNamespace(PropertyValue).Get(FString()),
FTextInspector::GetKey(PropertyValue).Get(FString()),
NewNamespace,
NewKey
);
}
#else // USE_STABLE_LOCALIZATION_KEYS
{
// We want to preserve the namespace set on this property if it's *not* the default value
if (!EditableTextProperty->IsDefaultValue())
{
// Some properties report that they're not the default, but still haven't been set from a property, so we also check the property key to see if it's a valid GUID before allowing the namespace to persist
FGuid TmpGuid;
if (FGuid::Parse(FTextInspector::GetKey(PropertyValue).Get(FString()), TmpGuid))
{
NewNamespace = FTextInspector::GetNamespace(PropertyValue).Get(FString());
}
}
NewKey = FGuid::NewGuid().ToString();
}
#endif // USE_STABLE_LOCALIZATION_KEYS
EditableTextProperty->SetText(TextIndex, FText::ChangeKey(NewNamespace, NewKey, NewText));
}
}
}
void STextPropertyEditableTextBox::SetTextError(const FText& InErrorMsg)
{
if (MultiLineWidget.IsValid())
{
MultiLineWidget->SetError(InErrorMsg);
}
if (SingleLineWidget.IsValid())
{
SingleLineWidget->SetError(InErrorMsg);
}
}
FText STextPropertyEditableTextBox::GetNamespaceValue() const
{
FText NamespaceValue;
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
TOptional<FString> FoundNamespace = FTextInspector::GetNamespace(PropertyValue);
if (FoundNamespace.IsSet())
{
NamespaceValue = FText::FromString(TextNamespaceUtil::StripPackageNamespace(FoundNamespace.GetValue()));
}
}
else if (NumTexts > 1)
{
NamespaceValue = MultipleValuesText;
}
return NamespaceValue;
}
void STextPropertyEditableTextBox::OnNamespaceChanged(const FText& NewText)
{
FText ErrorMessage;
const FText ErrorCtx = LOCTEXT("TextNamespaceErrorCtx", "Namespace");
IsValidIdentity(NewText, &ErrorMessage, &ErrorCtx);
NamespaceEditableTextBox->SetError(ErrorMessage);
}
void STextPropertyEditableTextBox::OnNamespaceCommitted(const FText& NewText, ETextCommit::Type CommitInfo)
{
if (!IsValidIdentity(NewText))
{
return;
}
const int32 NumTexts = EditableTextProperty->GetNumTexts();
// Don't commit the Multiple Values text if there are multiple properties being set
if (NumTexts > 0 && (NumTexts == 1 || NewText.ToString() != MultipleValuesText.ToString()))
{
const FString& TextNamespace = NewText.ToString();
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText PropertyValue = EditableTextProperty->GetText(TextIndex);
// Only apply the change if the new namespace is different - we want to keep the keys stable where possible
const FString CurrentTextNamespace = TextNamespaceUtil::StripPackageNamespace(FTextInspector::GetNamespace(PropertyValue).Get(FString()));
if (CurrentTextNamespace.Equals(TextNamespace, ESearchCase::CaseSensitive))
{
continue;
}
// Get the stable namespace and key that we should use for this property
FString NewNamespace;
FString NewKey;
#if USE_STABLE_LOCALIZATION_KEYS
{
const FString* TextSource = FTextInspector::GetSourceString(PropertyValue);
EditableTextProperty->GetStableTextId(
TextIndex,
IEditableTextProperty::ETextPropertyEditAction::EditedNamespace,
TextSource ? *TextSource : FString(),
TextNamespace,
FTextInspector::GetKey(PropertyValue).Get(FString()),
NewNamespace,
NewKey
);
}
#else // USE_STABLE_LOCALIZATION_KEYS
{
NewNamespace = TextNamespace;
// If the current key is a GUID, then we can preserve that when setting the new namespace
NewKey = FTextInspector::GetKey(PropertyValue).Get(FString());
{
FGuid TmpGuid;
if (!FGuid::Parse(NewKey, TmpGuid))
{
NewKey = FGuid::NewGuid().ToString();
}
}
}
#endif // USE_STABLE_LOCALIZATION_KEYS
EditableTextProperty->SetText(TextIndex, FText::ChangeKey(NewNamespace, NewKey, PropertyValue));
}
}
}
FText STextPropertyEditableTextBox::GetKeyValue() const
{
FText KeyValue;
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
TOptional<FString> FoundKey = FTextInspector::GetKey(PropertyValue);
if (FoundKey.IsSet())
{
KeyValue = FText::FromString(FoundKey.GetValue());
}
}
else if (NumTexts > 1)
{
KeyValue = MultipleValuesText;
}
return KeyValue;
}
#if USE_STABLE_LOCALIZATION_KEYS
void STextPropertyEditableTextBox::OnKeyChanged(const FText& NewText)
{
FText ErrorMessage;
const FText ErrorCtx = LOCTEXT("TextKeyErrorCtx", "Key");
const bool bIsValidName = IsValidIdentity(NewText, &ErrorMessage, &ErrorCtx);
if (NewText.IsEmptyOrWhitespace())
{
ErrorMessage = LOCTEXT("TextKeyEmptyErrorMsg", "Key cannot be empty so a new key will be assigned");
}
else if (bIsValidName)
{
// Valid name, so check it won't cause an identity conflict (only test if we have a single text selected to avoid confusion)
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
const FString TextNamespace = FTextInspector::GetNamespace(PropertyValue).Get(FString());
const FString TextKey = NewText.ToString();
// Get the stable namespace and key that we should use for this property
// If it comes back with the same namespace but a different key then it means there was an identity conflict
FString NewNamespace;
FString NewKey;
const FString* TextSource = FTextInspector::GetSourceString(PropertyValue);
EditableTextProperty->GetStableTextId(
0,
IEditableTextProperty::ETextPropertyEditAction::EditedKey,
TextSource ? *TextSource : FString(),
TextNamespace,
TextKey,
NewNamespace,
NewKey
);
if (TextNamespace.Equals(NewNamespace, ESearchCase::CaseSensitive) && !TextKey.Equals(NewKey, ESearchCase::CaseSensitive))
{
ErrorMessage = LOCTEXT("TextKeyConflictErrorMsg", "Identity (namespace & key) is being used by a different text within this package so a new key will be assigned");
}
}
}
KeyEditableTextBox->SetError(ErrorMessage);
}
void STextPropertyEditableTextBox::OnKeyCommitted(const FText& NewText, ETextCommit::Type CommitInfo)
{
if (!IsValidIdentity(NewText))
{
return;
}
const int32 NumTexts = EditableTextProperty->GetNumTexts();
// Don't commit the Multiple Values text if there are multiple properties being set
if (NumTexts > 0 && (NumTexts == 1 || NewText.ToString() != MultipleValuesText.ToString()))
{
const FString& TextKey = NewText.ToString();
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText PropertyValue = EditableTextProperty->GetText(TextIndex);
// Only apply the change if the new key is different - we want to keep the keys stable where possible
const FString CurrentTextKey = FTextInspector::GetKey(PropertyValue).Get(FString());
if (CurrentTextKey.Equals(TextKey, ESearchCase::CaseSensitive))
{
continue;
}
// Get the stable namespace and key that we should use for this property
FString NewNamespace;
FString NewKey;
const FString* TextSource = FTextInspector::GetSourceString(PropertyValue);
EditableTextProperty->GetStableTextId(
TextIndex,
IEditableTextProperty::ETextPropertyEditAction::EditedKey,
TextSource ? *TextSource : FString(),
FTextInspector::GetNamespace(PropertyValue).Get(FString()),
TextKey,
NewNamespace,
NewKey
);
EditableTextProperty->SetText(TextIndex, FText::ChangeKey(NewNamespace, NewKey, PropertyValue));
}
}
}
FText STextPropertyEditableTextBox::GetPackageValue() const
{
FText PackageValue;
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
TOptional<FString> FoundNamespace = FTextInspector::GetNamespace(PropertyValue);
if (FoundNamespace.IsSet())
{
PackageValue = FText::FromString(TextNamespaceUtil::ExtractPackageNamespace(FoundNamespace.GetValue()));
}
}
else if (NumTexts > 1)
{
PackageValue = MultipleValuesText;
}
return PackageValue;
}
#endif // USE_STABLE_LOCALIZATION_KEYS
ECheckBoxState STextPropertyEditableTextBox::GetLocalizableCheckState(bool bActiveState) const
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
const bool bIsLocalized = !PropertyValue.IsCultureInvariant();
return bIsLocalized == bActiveState ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}
return ECheckBoxState::Undetermined;
}
void STextPropertyEditableTextBox::HandleLocalizableCheckStateChanged(ECheckBoxState InCheckboxState, bool bActiveState)
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (bActiveState)
{
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText PropertyValue = EditableTextProperty->GetText(TextIndex);
// Assign a key to any currently culture invariant texts
if (PropertyValue.IsCultureInvariant())
{
// Get the stable namespace and key that we should use for this property
FString NewNamespace;
FString NewKey;
EditableTextProperty->GetStableTextId(
TextIndex,
IEditableTextProperty::ETextPropertyEditAction::EditedKey,
PropertyValue.ToString(),
FString(),
FString(),
NewNamespace,
NewKey
);
EditableTextProperty->SetText(TextIndex, FInternationalization::Get().ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(*PropertyValue.ToString(), *NewNamespace, *NewKey));
}
}
}
else
{
for (int32 TextIndex = 0; TextIndex < NumTexts; ++TextIndex)
{
const FText PropertyValue = EditableTextProperty->GetText(TextIndex);
// Clear the identity from any non-culture invariant texts
if (!PropertyValue.IsCultureInvariant())
{
const FString* TextSource = FTextInspector::GetSourceString(PropertyValue);
EditableTextProperty->SetText(TextIndex, FText::AsCultureInvariant(PropertyValue.ToString()));
}
}
}
}
EVisibility STextPropertyEditableTextBox::GetTextWarningImageVisibility() const
{
const int32 NumTexts = EditableTextProperty->GetNumTexts();
if (NumTexts == 1)
{
const FText PropertyValue = EditableTextProperty->GetText(0);
return PropertyValue.IsCultureInvariant() ? EVisibility::Visible : EVisibility::Collapsed;
}
return EVisibility::Collapsed;
}
bool STextPropertyEditableTextBox::IsValidIdentity(const FText& InIdentity, FText* OutReason, const FText* InErrorCtx) const
{
const FString InvalidIdentityChars = FString::Printf(TEXT("%s%c%c"), INVALID_NAME_CHARACTERS, TextNamespaceUtil::PackageNamespaceStartMarker, TextNamespaceUtil::PackageNamespaceEndMarker);
return FName::IsValidXName(InIdentity.ToString(), InvalidIdentityChars, OutReason, InErrorCtx);
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink