aiden
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Host: Add disambiguation variants for translations

Browse Source
pull/3300/head
Stenzek 1 year ago
parent 060c5553c0
commit a7d8e6d018
No known key found for this signature in database
13 changed files with 312 additions and 237 deletions
Show Stats Download Patch File Download Diff File

74
src/core/game_database.cpp
Unescape Escape View File

@ -54,14 +54,24 @@ static bool ParseYamlCodes(u32 index, const ryml::ConstNodeRef& value, std::stri
static bool LoadTrackHashes();
static constexpr const std::array<const char*, static_cast<int>(CompatibilityRating::Count)>
s_compatibility_rating_names = {
{"Unknown", "DoesntBoot", "CrashesInIntro", "CrashesInGame", "GraphicalAudioIssues", "NoIssues"}};
s_compatibility_rating_names = {{
"Unknown",
"DoesntBoot",
"CrashesInIntro",
"CrashesInGame",
"GraphicalAudioIssues",
"NoIssues",
}};
static constexpr const std::array<const char*, static_cast<size_t>(CompatibilityRating::Count)>
s_compatibility_rating_display_names = {
{TRANSLATE_NOOP("GameDatabase", "Unknown"), TRANSLATE_NOOP("GameDatabase", "Doesn't Boot"),
TRANSLATE_NOOP("GameDatabase", "Crashes In Intro"), TRANSLATE_NOOP("GameDatabase", "Crashes In-Game"),
TRANSLATE_NOOP("GameDatabase", "Graphical/Audio Issues"), TRANSLATE_NOOP("GameDatabase", "No Issues")}};
s_compatibility_rating_display_names = {{
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Unknown", "CompatibilityRating"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Doesn't Boot", "CompatibilityRating"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Crashes In Intro", "CompatibilityRating"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Crashes In-Game", "CompatibilityRating"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Graphical/Audio Issues", "CompatibilityRating"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "No Issues", "CompatibilityRating"),
}};
static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Trait::Count)> s_trait_names = {{
"ForceInterpreter",
@ -93,32 +103,32 @@ static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Tr
}};
static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Trait::Count)> s_trait_display_names = {{
TRANSLATE_NOOP("GameDatabase", "Force Interpreter"),
TRANSLATE_NOOP("GameDatabase", "Force Software Renderer"),
TRANSLATE_NOOP("GameDatabase", "Force Software Renderer For Readbacks"),
TRANSLATE_NOOP("GameDatabase", "Force Round Texture Coordinates"),
TRANSLATE_NOOP("GameDatabase", "Force Accurate Blending"),
TRANSLATE_NOOP("GameDatabase", "Force Interlacing"),
TRANSLATE_NOOP("GameDatabase", "Disable Automatic Analog Mode"),
TRANSLATE_NOOP("GameDatabase", "Disable True Color"),
TRANSLATE_NOOP("GameDatabase", "Disable Upscaling"),
TRANSLATE_NOOP("GameDatabase", "Disable Texture Filtering"),
TRANSLATE_NOOP("GameDatabase", "Disable Sprite Texture Filtering"),
TRANSLATE_NOOP("GameDatabase", "Disable Scaled Dithering"),
TRANSLATE_NOOP("GameDatabase", "Disable Widescreen"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP Culling"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP Texture Correction"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP Color Correction"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP Depth Buffer"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP Preserve Projection Floating Point"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP on 2D Polygons"),
TRANSLATE_NOOP("GameDatabase", "Force PGXP Vertex Cache"),
TRANSLATE_NOOP("GameDatabase", "Force PGXP CPU Mode"),
TRANSLATE_NOOP("GameDatabase", "Force Recompiler Memory Exceptions"),
TRANSLATE_NOOP("GameDatabase", "Force Recompiler ICache"),
TRANSLATE_NOOP("GameDatabase", "Force Recompiler LUT Fastmem"),
TRANSLATE_NOOP("GameDatabase", "Is LibCrypt Protected"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Interpreter", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Software Renderer", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Software Renderer For Readbacks", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Round Texture Coordinates", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Accurate Blending", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Interlacing", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable Automatic Analog Mode", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable True Color", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable Upscaling", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable Texture Filtering", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable Sprite Texture Filtering", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable Scaled Dithering", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable Widescreen", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP Culling", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP Texture Correction", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP Color Correction", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP Depth Buffer", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP Preserve Projection Floating Point", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Disable PGXP on 2D Polygons", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force PGXP Vertex Cache", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force PGXP CPU Mode", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Recompiler Memory Exceptions", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Recompiler ICache", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Force Recompiler LUT Fastmem", "GameDatabase::Trait"),
TRANSLATE_DISAMBIG_NOOP("GameDatabase", "Is LibCrypt Protected", "GameDatabase::Trait"),
}};
static constexpr const char* GAMEDB_YAML_FILENAME = "gamedb.yaml";

26
src/core/game_list.cpp
Unescape Escape View File

@ -131,17 +131,26 @@ static bool s_game_list_loaded = false;
const char* GameList::GetEntryTypeName(EntryType type)
{
static std::array<const char*, static_cast<int>(EntryType::Count)> names = {
{"Disc", "DiscSet", "PSExe", "Playlist", "PSF"}};
return names[static_cast<int>(type)];
static std::array<const char*, static_cast<int>(EntryType::Count)> names = {{
"Disc",
"DiscSet",
"PSExe",
"Playlist",
"PSF",
}};
return names[static_cast<size_t>(type)];
}
const char* GameList::GetEntryTypeDisplayName(EntryType type)
{
static std::array<const char*, static_cast<int>(EntryType::Count)> names = {
{TRANSLATE_NOOP("GameList", "Disc"), TRANSLATE_NOOP("GameList", "Disc Set"), TRANSLATE_NOOP("GameList", "PS-EXE"),
TRANSLATE_NOOP("GameList", "Playlist"), TRANSLATE_NOOP("GameList", "PSF")}};
return Host::TranslateToCString("GameList", names[static_cast<int>(type)]);
static std::array<const char*, static_cast<int>(EntryType::Count)> names = {{
TRANSLATE_DISAMBIG_NOOP("GameList", "Disc", "EntryType"),
TRANSLATE_DISAMBIG_NOOP("GameList", "Disc Set", "EntryType"),
TRANSLATE_DISAMBIG_NOOP("GameList", "PS-EXE", "EntryType"),
TRANSLATE_DISAMBIG_NOOP("GameList", "Playlist", "EntryType"),
TRANSLATE_DISAMBIG_NOOP("GameList", "PSF", "EntryType"),
}};
return Host::TranslateToCString("GameList", names[static_cast<size_t>(type)], "EntryType");
}
bool GameList::IsGameListLoaded()
@ -831,7 +840,8 @@ GameList::EntryList GameList::TakeEntryList()
return ret;
}
void GameList::CreateDiscSetEntries(const std::vector<std::string>& excluded_paths, const PlayedTimeMap& played_time_map)
void GameList::CreateDiscSetEntries(const std::vector<std::string>& excluded_paths,
const PlayedTimeMap& played_time_map)
{
std::unique_lock lock(s_mutex);

311
src/core/settings.cpp
Unescape Escape View File

@ -906,10 +906,14 @@ static constexpr const std::array s_log_level_names = {
"None", "Error", "Warning", "Info", "Verbose", "Dev", "Debug", "Trace",
};
static constexpr const std::array s_log_level_display_names = {
TRANSLATE_NOOP("LogLevel", "None"), TRANSLATE_NOOP("LogLevel", "Error"),
TRANSLATE_NOOP("LogLevel", "Warning"), TRANSLATE_NOOP("LogLevel", "Information"),
TRANSLATE_NOOP("LogLevel", "Verbose"), TRANSLATE_NOOP("LogLevel", "Developer"),
TRANSLATE_NOOP("LogLevel", "Debug"), TRANSLATE_NOOP("LogLevel", "Trace"),
TRANSLATE_DISAMBIG_NOOP("Settings", "None", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Error", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Warning", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Information", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Verbose", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Developer", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Debug", "LogLevel"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Trace", "LogLevel"),
};
std::optional<LOGLEVEL> Settings::ParseLogLevelName(const char* str)
@ -933,13 +937,21 @@ const char* Settings::GetLogLevelName(LOGLEVEL level)
const char* Settings::GetLogLevelDisplayName(LOGLEVEL level)
{
return Host::TranslateToCString("LogLevel", s_log_level_display_names[static_cast<size_t>(level)]);
return Host::TranslateToCString("Settings", s_log_level_display_names[static_cast<size_t>(level)], "LogLevel");
}
static constexpr const std::array s_console_region_names = {"Auto", "NTSC-J", "NTSC-U", "PAL"};
static constexpr const std::array s_console_region_names = {
"Auto",
"NTSC-J",
"NTSC-U",
"PAL",
};
static constexpr const std::array s_console_region_display_names = {
TRANSLATE_NOOP("ConsoleRegion", "Auto-Detect"), TRANSLATE_NOOP("ConsoleRegion", "NTSC-J (Japan)"),
TRANSLATE_NOOP("ConsoleRegion", "NTSC-U/C (US, Canada)"), TRANSLATE_NOOP("ConsoleRegion", "PAL (Europe, Australia)")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Auto-Detect", "ConsoleRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "NTSC-J (Japan)", "ConsoleRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "NTSC-U/C (US, Canada)", "ConsoleRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "PAL (Europe, Australia)", "ConsoleRegion"),
};
std::optional<ConsoleRegion> Settings::ParseConsoleRegionName(const char* str)
{
@ -962,14 +974,20 @@ const char* Settings::GetConsoleRegionName(ConsoleRegion region)
const char* Settings::GetConsoleRegionDisplayName(ConsoleRegion region)
{
return Host::TranslateToCString("ConsoleRegion", s_console_region_display_names[static_cast<size_t>(region)]);
return Host::TranslateToCString("Settings", s_console_region_display_names[static_cast<size_t>(region)],
"ConsoleRegion");
}
static constexpr const std::array s_disc_region_names = {"NTSC-J", "NTSC-U", "PAL", "Other", "Non-PS1"};
static constexpr const std::array s_disc_region_names = {
"NTSC-J", "NTSC-U", "PAL", "Other", "Non-PS1",
};
static constexpr const std::array s_disc_region_display_names = {
TRANSLATE_NOOP("DiscRegion", "NTSC-J (Japan)"), TRANSLATE_NOOP("DiscRegion", "NTSC-U/C (US, Canada)"),
TRANSLATE_NOOP("DiscRegion", "PAL (Europe, Australia)"), TRANSLATE_NOOP("DiscRegion", "Other"),
TRANSLATE_NOOP("DiscRegion", "Non-PS1")};
TRANSLATE_DISAMBIG_NOOP("Settings", "NTSC-J (Japan)", "DiscRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "NTSC-U/C (US, Canada)", "DiscRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "PAL (Europe, Australia)", "DiscRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Other", "DiscRegion"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Non-PS1", "DiscRegion"),
};
std::optional<DiscRegion> Settings::ParseDiscRegionName(const char* str)
{
@ -992,16 +1010,21 @@ const char* Settings::GetDiscRegionName(DiscRegion region)
const char* Settings::GetDiscRegionDisplayName(DiscRegion region)
{
return Host::TranslateToCString("DiscRegion", s_disc_region_display_names[static_cast<size_t>(region)]);
return Host::TranslateToCString("Settings", s_disc_region_display_names[static_cast<size_t>(region)], "DiscRegion");
}
static constexpr const std::array s_cpu_execution_mode_names = {"Interpreter", "CachedInterpreter", "Recompiler",
"NewRec"};
static constexpr const std::array s_cpu_execution_mode_names = {
"Interpreter",
"CachedInterpreter",
"Recompiler",
"NewRec",
};
static constexpr const std::array s_cpu_execution_mode_display_names = {
TRANSLATE_NOOP("CPUExecutionMode", "Interpreter (Slowest)"),
TRANSLATE_NOOP("CPUExecutionMode", "Cached Interpreter (Faster)"),
TRANSLATE_NOOP("CPUExecutionMode", "Recompiler (Fastest)"),
TRANSLATE_NOOP("CPUExecutionMode", "New Recompiler (Experimental)")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Interpreter (Slowest)", "CPUExecutionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Cached Interpreter (Faster)", "CPUExecutionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Recompiler (Fastest)", "CPUExecutionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "New Recompiler (Experimental)", "CPUExecutionMode"),
};
std::optional<CPUExecutionMode> Settings::ParseCPUExecutionMode(const char* str)
{
@ -1024,14 +1047,20 @@ const char* Settings::GetCPUExecutionModeName(CPUExecutionMode mode)
const char* Settings::GetCPUExecutionModeDisplayName(CPUExecutionMode mode)
{
return Host::TranslateToCString("CPUExecutionMode", s_cpu_execution_mode_display_names[static_cast<u8>(mode)]);
return Host::TranslateToCString("Settings", s_cpu_execution_mode_display_names[static_cast<size_t>(mode)],
"CPUExecutionMode");
}
static constexpr const std::array s_cpu_fastmem_mode_names = {"Disabled", "MMap", "LUT"};
static constexpr const std::array s_cpu_fastmem_mode_names = {
"Disabled",
"MMap",
"LUT",
};
static constexpr const std::array s_cpu_fastmem_mode_display_names = {
TRANSLATE_NOOP("CPUFastmemMode", "Disabled (Slowest)"),
TRANSLATE_NOOP("CPUFastmemMode", "MMap (Hardware, Fastest, 64-Bit Only)"),
TRANSLATE_NOOP("CPUFastmemMode", "LUT (Faster)")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled (Slowest)", "CPUFastmemMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "MMap (Hardware, Fastest, 64-Bit Only)", "CPUFastmemMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "LUT (Faster)", "CPUFastmemMode"),
};
std::optional<CPUFastmemMode> Settings::ParseCPUFastmemMode(const char* str)
{
@ -1054,7 +1083,8 @@ const char* Settings::GetCPUFastmemModeName(CPUFastmemMode mode)
const char* Settings::GetCPUFastmemModeDisplayName(CPUFastmemMode mode)
{
return Host::TranslateToCString("CPUFastmemMode", s_cpu_fastmem_mode_display_names[static_cast<u8>(mode)]);
return Host::TranslateToCString("Settings", s_cpu_fastmem_mode_display_names[static_cast<size_t>(mode)],
"CPUFastmemMode");
}
static constexpr const std::array s_gpu_renderer_names = {
@ -1074,20 +1104,21 @@ static constexpr const std::array s_gpu_renderer_names = {
"Software",
};
static constexpr const std::array s_gpu_renderer_display_names = {
TRANSLATE_NOOP("GPURenderer", "Automatic"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Automatic", "GPURenderer"),
#ifdef _WIN32
TRANSLATE_NOOP("GPURenderer", "Direct3D 11"), TRANSLATE_NOOP("GPURenderer", "Direct3D 12"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Direct3D 11", "GPURenderer"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Direct3D 12", "GPURenderer"),
#endif
#ifdef __APPLE__
TRANSLATE_NOOP("GPURenderer", "Metal"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Metal", "GPURenderer"),
#endif
#ifdef ENABLE_VULKAN
TRANSLATE_NOOP("GPURenderer", "Vulkan"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Vulkan", "GPURenderer"),
#endif
#ifdef ENABLE_OPENGL
TRANSLATE_NOOP("GPURenderer", "OpenGL"),
TRANSLATE_DISAMBIG_NOOP("Settings", "OpenGL", "GPURenderer"),
#endif
TRANSLATE_NOOP("GPURenderer", "Software"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Software", "GPURenderer"),
};
std::optional<GPURenderer> Settings::ParseRendererName(const char* str)
@ -1111,7 +1142,8 @@ const char* Settings::GetRendererName(GPURenderer renderer)
const char* Settings::GetRendererDisplayName(GPURenderer renderer)
{
return Host::TranslateToCString("GPURenderer", s_gpu_renderer_display_names[static_cast<size_t>(renderer)]);
return Host::TranslateToCString("Settings", s_gpu_renderer_display_names[static_cast<size_t>(renderer)],
"GPURenderer");
}
RenderAPI Settings::GetRenderAPIForRenderer(GPURenderer renderer)
@ -1184,13 +1216,13 @@ static constexpr const std::array s_texture_filter_names = {
"Nearest", "Bilinear", "BilinearBinAlpha", "JINC2", "JINC2BinAlpha", "xBR", "xBRBinAlpha",
};
static constexpr const std::array s_texture_filter_display_names = {
TRANSLATE_NOOP("GPUTextureFilter", "Nearest-Neighbor"),
TRANSLATE_NOOP("GPUTextureFilter", "Bilinear"),
TRANSLATE_NOOP("GPUTextureFilter", "Bilinear (No Edge Blending)"),
TRANSLATE_NOOP("GPUTextureFilter", "JINC2 (Slow)"),
TRANSLATE_NOOP("GPUTextureFilter", "JINC2 (Slow, No Edge Blending)"),
TRANSLATE_NOOP("GPUTextureFilter", "xBR (Very Slow)"),
TRANSLATE_NOOP("GPUTextureFilter", "xBR (Very Slow, No Edge Blending)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Nearest-Neighbor", "GPUTextureFilter"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Bilinear", "GPUTextureFilter"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Bilinear (No Edge Blending)", "GPUTextureFilter"),
TRANSLATE_DISAMBIG_NOOP("Settings", "JINC2 (Slow)", "GPUTextureFilter"),
TRANSLATE_DISAMBIG_NOOP("Settings", "JINC2 (Slow, No Edge Blending)", "GPUTextureFilter"),
TRANSLATE_DISAMBIG_NOOP("Settings", "xBR (Very Slow)", "GPUTextureFilter"),
TRANSLATE_DISAMBIG_NOOP("Settings", "xBR (Very Slow, No Edge Blending)", "GPUTextureFilter"),
};
std::optional<GPUTextureFilter> Settings::ParseTextureFilterName(const char* str)
@ -1214,7 +1246,8 @@ const char* Settings::GetTextureFilterName(GPUTextureFilter filter)
const char* Settings::GetTextureFilterDisplayName(GPUTextureFilter filter)
{
return Host::TranslateToCString("GPUTextureFilter", s_texture_filter_display_names[static_cast<size_t>(filter)]);
return Host::TranslateToCString("Settings", s_texture_filter_display_names[static_cast<size_t>(filter)],
"GPUTextureFilter");
}
static constexpr const std::array s_line_detect_mode_names = {
@ -1224,10 +1257,10 @@ static constexpr const std::array s_line_detect_mode_names = {
"AggressiveTriangles",
};
static constexpr const std::array s_line_detect_mode_detect_names = {
TRANSLATE_NOOP("GPULineDetectMode", "Disabled"),
TRANSLATE_NOOP("GPULineDetectMode", "Quads"),
TRANSLATE_NOOP("GPULineDetectMode", "Triangles (Basic)"),
TRANSLATE_NOOP("GPULineDetectMode", "Triangles (Aggressive)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled", "GPULineDetectMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Quads", "GPULineDetectMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Triangles (Basic)", "GPULineDetectMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Triangles (Aggressive)", "GPULineDetectMode"),
};
std::optional<GPULineDetectMode> Settings::ParseLineDetectModeName(const char* str)
@ -1251,14 +1284,15 @@ const char* Settings::GetLineDetectModeName(GPULineDetectMode mode)
const char* Settings::GetLineDetectModeDisplayName(GPULineDetectMode mode)
{
return Host::TranslateToCString("GPULineDetectMode", s_line_detect_mode_detect_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_line_detect_mode_detect_names[static_cast<size_t>(mode)],
"GPULineDetectMode");
}
static constexpr const std::array s_downsample_mode_names = {"Disabled", "Box", "Adaptive"};
static constexpr const std::array s_downsample_mode_display_names = {
TRANSLATE_NOOP("GPUDownsampleMode", "Disabled"),
TRANSLATE_NOOP("GPUDownsampleMode", "Box (Downsample 3D/Smooth All)"),
TRANSLATE_NOOP("GPUDownsampleMode", "Adaptive (Preserve 3D/Smooth 2D)")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled", "GPUDownsampleMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Box (Downsample 3D/Smooth All)", "GPUDownsampleMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Adaptive (Preserve 3D/Smooth 2D)", "GPUDownsampleMode")};
std::optional<GPUDownsampleMode> Settings::ParseDownsampleModeName(const char* str)
{
@ -1281,13 +1315,15 @@ const char* Settings::GetDownsampleModeName(GPUDownsampleMode mode)
const char* Settings::GetDownsampleModeDisplayName(GPUDownsampleMode mode)
{
return Host::TranslateToCString("GPUDownsampleMode", s_downsample_mode_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_downsample_mode_display_names[static_cast<size_t>(mode)],
"GPUDownsampleMode");
}
static constexpr const std::array s_wireframe_mode_names = {"Disabled", "OverlayWireframe", "OnlyWireframe"};
static constexpr const std::array s_wireframe_mode_display_names = {
TRANSLATE_NOOP("GPUWireframeMode", "Disabled"), TRANSLATE_NOOP("GPUWireframeMode", "Overlay Wireframe"),
TRANSLATE_NOOP("GPUWireframeMode", "Only Wireframe")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled", "GPUWireframeMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Overlay Wireframe", "GPUWireframeMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Only Wireframe", "GPUWireframeMode")};
std::optional<GPUWireframeMode> Settings::ParseGPUWireframeMode(const char* str)
{
@ -1310,22 +1346,19 @@ const char* Settings::GetGPUWireframeModeName(GPUWireframeMode mode)
const char* Settings::GetGPUWireframeModeDisplayName(GPUWireframeMode mode)
{
return Host::TranslateToCString("GPUWireframeMode", s_wireframe_mode_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_wireframe_mode_display_names[static_cast<size_t>(mode)],
"GPUWireframeMode");
}
static constexpr const std::array s_display_deinterlacing_mode_names = {
"Disabled",
"Weave",
"Blend",
"Adaptive",
"Progressive",
"Disabled", "Weave", "Blend", "Adaptive", "Progressive",
};
static constexpr const std::array s_display_deinterlacing_mode_display_names = {
TRANSLATE_NOOP("DisplayDeinterlacingMode", "Disabled (Flickering)"),
TRANSLATE_NOOP("DisplayDeinterlacingMode", "Weave (Combing)"),
TRANSLATE_NOOP("DisplayDeinterlacingMode", "Blend (Blur)"),
TRANSLATE_NOOP("DisplayDeinterlacingMode", "Adaptive (FastMAD)"),
TRANSLATE_NOOP("DisplayDeinterlacingMode", "Progressive (Optimal)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled (Flickering)", "DisplayDeinterlacingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Weave (Combing)", "DisplayDeinterlacingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Blend (Blur)", "DisplayDeinterlacingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Adaptive (FastMAD)", "DisplayDeinterlacingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Progressive (Optimal)", "DisplayDeinterlacingMode"),
};
std::optional<DisplayDeinterlacingMode> Settings::ParseDisplayDeinterlacingMode(const char* str)
@ -1349,14 +1382,16 @@ const char* Settings::GetDisplayDeinterlacingModeName(DisplayDeinterlacingMode m
const char* Settings::GetDisplayDeinterlacingModeDisplayName(DisplayDeinterlacingMode mode)
{
return Host::TranslateToCString("DisplayDeinterlacingMode",
s_display_deinterlacing_mode_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_display_deinterlacing_mode_display_names[static_cast<size_t>(mode)],
"DisplayDeinterlacingMode");
}
static constexpr const std::array s_display_crop_mode_names = {"None", "Overscan", "Borders"};
static constexpr const std::array s_display_crop_mode_display_names = {
TRANSLATE_NOOP("DisplayCropMode", "None"), TRANSLATE_NOOP("DisplayCropMode", "Only Overscan Area"),
TRANSLATE_NOOP("DisplayCropMode", "All Borders")};
TRANSLATE_DISAMBIG_NOOP("Settings", "None", "DisplayCropMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Only Overscan Area", "DisplayCropMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "All Borders", "DisplayCropMode"),
};
std::optional<DisplayCropMode> Settings::ParseDisplayCropMode(const char* str)
{
@ -1379,14 +1414,15 @@ const char* Settings::GetDisplayCropModeName(DisplayCropMode crop_mode)
const char* Settings::GetDisplayCropModeDisplayName(DisplayCropMode crop_mode)
{
return Host::TranslateToCString("DisplayCropMode", s_display_crop_mode_display_names[static_cast<size_t>(crop_mode)]);
return Host::TranslateToCString("Settings", s_display_crop_mode_display_names[static_cast<size_t>(crop_mode)],
"DisplayCropMode");
}
static constexpr const std::array s_display_aspect_ratio_names = {
#ifndef __ANDROID__
TRANSLATE_NOOP("DisplayAspectRatio", "Auto (Game Native)"),
TRANSLATE_NOOP("DisplayAspectRatio", "Stretch To Fill"),
TRANSLATE_NOOP("DisplayAspectRatio", "Custom"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Auto (Game Native)", "DisplayAspectRatio"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Stretch To Fill", "DisplayAspectRatio"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Custom", "DisplayAspectRatio"),
#else
"Auto (Game Native)",
"Auto (Match Window)",
@ -1421,7 +1457,8 @@ const char* Settings::GetDisplayAspectRatioName(DisplayAspectRatio ar)
const char* Settings::GetDisplayAspectRatioDisplayName(DisplayAspectRatio ar)
{
return Host::TranslateToCString("DisplayAspectRatio", s_display_aspect_ratio_names[static_cast<size_t>(ar)]);
return Host::TranslateToCString("Settings", s_display_aspect_ratio_names[static_cast<size_t>(ar)],
"DisplayAspectRatio");
}
float Settings::GetDisplayAspectRatioValue() const
@ -1451,8 +1488,10 @@ float Settings::GetDisplayAspectRatioValue() const
static constexpr const std::array s_display_alignment_names = {"LeftOrTop", "Center", "RightOrBottom"};
static constexpr const std::array s_display_alignment_display_names = {
TRANSLATE_NOOP("DisplayAlignment", "Left / Top"), TRANSLATE_NOOP("DisplayAlignment", "Center"),
TRANSLATE_NOOP("DisplayAlignment", "Right / Bottom")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Left / Top", "DisplayAlignment"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Center", "DisplayAlignment"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Right / Bottom", "DisplayAlignment"),
};
std::optional<DisplayAlignment> Settings::ParseDisplayAlignment(const char* str)
{
@ -1475,16 +1514,16 @@ const char* Settings::GetDisplayAlignmentName(DisplayAlignment alignment)
const char* Settings::GetDisplayAlignmentDisplayName(DisplayAlignment alignment)
{
return Host::TranslateToCString("DisplayAlignment",
s_display_alignment_display_names[static_cast<size_t>(alignment)]);
return Host::TranslateToCString("Settings", s_display_alignment_display_names[static_cast<size_t>(alignment)],
"DisplayAlignment");
}
static constexpr const std::array s_display_rotation_names = {"Normal", "Rotate90", "Rotate180", "Rotate270"};
static constexpr const std::array s_display_rotation_display_names = {
TRANSLATE_NOOP("Settings", "No Rotation"),
TRANSLATE_NOOP("Settings", "Rotate 90° (Clockwise)"),
TRANSLATE_NOOP("Settings", "Rotate 180° (Vertical Flip)"),
TRANSLATE_NOOP("Settings", "Rotate 270° (Clockwise)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "No Rotation", "DisplayRotation"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Rotate 90° (Clockwise)", "DisplayRotation"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Rotate 180° (Vertical Flip)", "DisplayRotation"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Rotate 270° (Clockwise)", "DisplayRotation"),
};
std::optional<DisplayRotation> Settings::ParseDisplayRotation(const char* str)
@ -1508,19 +1547,26 @@ const char* Settings::GetDisplayRotationName(DisplayRotation rotation)
const char* Settings::GetDisplayRotationDisplayName(DisplayRotation rotation)
{
return Host::TranslateToCString("Settings", s_display_rotation_display_names[static_cast<size_t>(rotation)]);
return Host::TranslateToCString("Settings", s_display_rotation_display_names[static_cast<size_t>(rotation)],
"DisplayRotation");
}
static constexpr const std::array s_display_force_video_timings_names = {
TRANSLATE_NOOP("Settings", "Disabled"),
static constexpr const std::array s_display_force_video_timing_names = {
"Disabled",
"NTSC",
"PAL",
};
static constexpr const std::array s_display_force_video_timing_display_names = {
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled", "ForceVideoTiming"),
TRANSLATE_DISAMBIG_NOOP("Settings", "NTSC (60hz)", "ForceVideoTiming"),
TRANSLATE_DISAMBIG_NOOP("Settings", "PAL (50hz)", "ForceVideoTiming"),
};
std::optional<ForceVideoTimingMode> Settings::ParseForceVideoTimingName(const char* str)
{
int index = 0;
for (const char* name : s_display_force_video_timings_names)
for (const char* name : s_display_force_video_timing_names)
{
if (StringUtil::Strcasecmp(name, str) == 0)
return static_cast<ForceVideoTimingMode>(index);
@ -1533,23 +1579,24 @@ std::optional<ForceVideoTimingMode> Settings::ParseForceVideoTimingName(const ch
const char* Settings::GetForceVideoTimingName(ForceVideoTimingMode mode)
{
return s_display_force_video_timings_names[static_cast<size_t>(mode)];
return s_display_force_video_timing_names[static_cast<size_t>(mode)];
}
const char* Settings::GetForceVideoTimingDisplayName(ForceVideoTimingMode mode)
{
return Host::TranslateToCString("Settings", s_display_force_video_timings_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_display_force_video_timing_display_names[static_cast<size_t>(mode)],
"ForceVideoTiming");
}
static constexpr const std::array s_display_scaling_names = {
"Nearest", "NearestInteger", "BilinearSmooth", "BilinearSharp", "BilinearInteger",
};
static constexpr const std::array s_display_scaling_display_names = {
TRANSLATE_NOOP("DisplayScalingMode", "Nearest-Neighbor"),
TRANSLATE_NOOP("DisplayScalingMode", "Nearest-Neighbor (Integer)"),
TRANSLATE_NOOP("DisplayScalingMode", "Bilinear (Smooth)"),
TRANSLATE_NOOP("DisplayScalingMode", "Bilinear (Sharp)"),
TRANSLATE_NOOP("DisplayScalingMode", "Bilinear (Integer)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Nearest-Neighbor", "DisplayScalingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Nearest-Neighbor (Integer)", "DisplayScalingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Bilinear (Smooth)", "DisplayScalingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Bilinear (Sharp)", "DisplayScalingMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Bilinear (Integer)", "DisplayScalingMode"),
};
std::optional<DisplayScalingMode> Settings::ParseDisplayScaling(const char* str)
@ -1573,7 +1620,8 @@ const char* Settings::GetDisplayScalingName(DisplayScalingMode mode)
const char* Settings::GetDisplayScalingDisplayName(DisplayScalingMode mode)
{
return Host::TranslateToCString("DisplayScalingMode", s_display_scaling_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_display_scaling_display_names[static_cast<size_t>(mode)],
"DisplayScalingMode");
}
static constexpr const std::array s_display_exclusive_fullscreen_mode_names = {
@ -1582,9 +1630,9 @@ static constexpr const std::array s_display_exclusive_fullscreen_mode_names = {
"Allowed",
};
static constexpr const std::array s_display_exclusive_fullscreen_mode_display_names = {
TRANSLATE_NOOP("Settings", "Automatic"),
TRANSLATE_NOOP("Settings", "Disallowed"),
TRANSLATE_NOOP("Settings", "Allowed"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Automatic", "DisplayExclusiveFullscreenControl"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Disallowed", "DisplayExclusiveFullscreenControl"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Allowed", "DisplayExclusiveFullscreenControl"),
};
std::optional<DisplayExclusiveFullscreenControl> Settings::ParseDisplayExclusiveFullscreenControl(const char* str)
@ -1609,7 +1657,8 @@ const char* Settings::GetDisplayExclusiveFullscreenControlName(DisplayExclusiveF
const char* Settings::GetDisplayExclusiveFullscreenControlDisplayName(DisplayExclusiveFullscreenControl mode)
{
return Host::TranslateToCString("Settings",
s_display_exclusive_fullscreen_mode_display_names[static_cast<size_t>(mode)]);
s_display_exclusive_fullscreen_mode_display_names[static_cast<size_t>(mode)],
"DisplayExclusiveFullscreenControl");
}
static constexpr const std::array s_display_screenshot_mode_names = {
@ -1618,9 +1667,9 @@ static constexpr const std::array s_display_screenshot_mode_names = {
"UncorrectedInternalResolution",
};
static constexpr const std::array s_display_screenshot_mode_display_names = {
TRANSLATE_NOOP("Settings", "Screen Resolution"),
TRANSLATE_NOOP("Settings", "Internal Resolution"),
TRANSLATE_NOOP("Settings", "Internal Resolution (Aspect Uncorrected)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Screen Resolution", "DisplayScreenshotMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Internal Resolution", "DisplayScreenshotMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Internal Resolution (Aspect Uncorrected)", "DisplayScreenshotMode"),
};
std::optional<DisplayScreenshotMode> Settings::ParseDisplayScreenshotMode(const char* str)
@ -1644,7 +1693,8 @@ const char* Settings::GetDisplayScreenshotModeName(DisplayScreenshotMode mode)
const char* Settings::GetDisplayScreenshotModeDisplayName(DisplayScreenshotMode mode)
{
return Host::TranslateToCString("Settings", s_display_screenshot_mode_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_display_screenshot_mode_display_names[static_cast<size_t>(mode)],
"DisplayScreenshotMode");
}
static constexpr const std::array s_display_screenshot_format_names = {
@ -1653,9 +1703,9 @@ static constexpr const std::array s_display_screenshot_format_names = {
"WebP",
};
static constexpr const std::array s_display_screenshot_format_display_names = {
TRANSLATE_NOOP("Settings", "PNG"),
TRANSLATE_NOOP("Settings", "JPEG"),
TRANSLATE_NOOP("Settings", "WebP"),
TRANSLATE_DISAMBIG_NOOP("Settings", "PNG", "DisplayScreenshotFormat"),
TRANSLATE_DISAMBIG_NOOP("Settings", "JPEG", "DisplayScreenshotFormat"),
TRANSLATE_DISAMBIG_NOOP("Settings", "WebP", "DisplayScreenshotFormat"),
};
static constexpr const std::array s_display_screenshot_format_extensions = {
"png",
@ -1684,7 +1734,8 @@ const char* Settings::GetDisplayScreenshotFormatName(DisplayScreenshotFormat for
const char* Settings::GetDisplayScreenshotFormatDisplayName(DisplayScreenshotFormat mode)
{
return Host::TranslateToCString("Settings", s_display_screenshot_format_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_display_screenshot_format_display_names[static_cast<size_t>(mode)],
"DisplayScreenshotFormat");
}
const char* Settings::GetDisplayScreenshotFormatExtension(DisplayScreenshotFormat format)
@ -1692,15 +1743,17 @@ const char* Settings::GetDisplayScreenshotFormatExtension(DisplayScreenshotForma
return s_display_screenshot_format_extensions[static_cast<size_t>(format)];
}
static constexpr const std::array s_memory_card_type_names = {"None", "Shared", "PerGame",
"PerGameTitle", "PerGameFileTitle", "NonPersistent"};
static constexpr const std::array s_memory_card_type_names = {
"None", "Shared", "PerGame", "PerGameTitle", "PerGameFileTitle", "NonPersistent",
};
static constexpr const std::array s_memory_card_type_display_names = {
TRANSLATE_NOOP("MemoryCardType", "No Memory Card"),
TRANSLATE_NOOP("MemoryCardType", "Shared Between All Games"),
TRANSLATE_NOOP("MemoryCardType", "Separate Card Per Game (Serial)"),
TRANSLATE_NOOP("MemoryCardType", "Separate Card Per Game (Title)"),
TRANSLATE_NOOP("MemoryCardType", "Separate Card Per Game (File Title)"),
TRANSLATE_NOOP("MemoryCardType", "Non-Persistent Card (Do Not Save)")};
TRANSLATE_DISAMBIG_NOOP("Settings", "No Memory Card", "MemoryCardType"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Shared Between All Games", "MemoryCardType"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Separate Card Per Game (Serial)", "MemoryCardType"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Separate Card Per Game (Title)", "MemoryCardType"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Separate Card Per Game (File Title)", "MemoryCardType"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Non-Persistent Card (Do Not Save)", "MemoryCardType"),
};
std::optional<MemoryCardType> Settings::ParseMemoryCardTypeName(const char* str)
{
@ -1723,7 +1776,8 @@ const char* Settings::GetMemoryCardTypeName(MemoryCardType type)
const char* Settings::GetMemoryCardTypeDisplayName(MemoryCardType type)
{
return Host::TranslateToCString("MemoryCardType", s_memory_card_type_display_names[static_cast<size_t>(type)]);
return Host::TranslateToCString("Settings", s_memory_card_type_display_names[static_cast<size_t>(type)],
"MemoryCardType");
}
std::string Settings::GetDefaultSharedMemoryCardName(u32 slot)
@ -1750,10 +1804,18 @@ std::string Settings::GetGameMemoryCardPath(std::string_view serial, u32 slot)
return Path::Combine(EmuFolders::MemoryCards, fmt::format("{}_{}.mcd", serial, slot + 1));
}
static constexpr const std::array s_multitap_enable_mode_names = {"Disabled", "Port1Only", "Port2Only", "BothPorts"};
static constexpr const std::array s_multitap_enable_mode_names = {
"Disabled",
"Port1Only",
"Port2Only",
"BothPorts",
};
static constexpr const std::array s_multitap_enable_mode_display_names = {
TRANSLATE_NOOP("MultitapMode", "Disabled"), TRANSLATE_NOOP("MultitapMode", "Enable on Port 1 Only"),
TRANSLATE_NOOP("MultitapMode", "Enable on Port 2 Only"), TRANSLATE_NOOP("MultitapMode", "Enable on Ports 1 and 2")};
TRANSLATE_DISAMBIG_NOOP("Settings", "Disabled", "MultitapMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Enable on Port 1 Only", "MultitapMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Enable on Port 2 Only", "MultitapMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Enable on Ports 1 and 2", "MultitapMode"),
};
std::optional<MultitapMode> Settings::ParseMultitapModeName(const char* str)
{
@ -1776,7 +1838,8 @@ const char* Settings::GetMultitapModeName(MultitapMode mode)
const char* Settings::GetMultitapModeDisplayName(MultitapMode mode)
{
return Host::TranslateToCString("MultitapMode", s_multitap_enable_mode_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_multitap_enable_mode_display_names[static_cast<size_t>(mode)],
"MultitapMode");
}
static constexpr const std::array s_mechacon_version_names = {"VC0A", "VC0B", "VC1A", "VC1B", "VD1", "VC2", "VC1",
@ -1814,10 +1877,13 @@ static constexpr const std::array s_save_state_compression_mode_names = {
"Uncompressed", "DeflateLow", "DeflateDefault", "DeflateHigh", "ZstLow", "ZstDefault", "ZstHigh",
};
static constexpr const std::array s_save_state_compression_mode_display_names = {
TRANSLATE_NOOP("Settings", "Uncompressed"), TRANSLATE_NOOP("Settings", "Deflate (Low)"),
TRANSLATE_NOOP("Settings", "Deflate (Default)"), TRANSLATE_NOOP("Settings", "Deflate (High)"),
TRANSLATE_NOOP("Settings", "Zstandard (Low)"), TRANSLATE_NOOP("Settings", "Zstandard (Default)"),
TRANSLATE_NOOP("Settings", "Zstandard (High)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Uncompressed", "SaveStateCompressionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Deflate (Low)", "SaveStateCompressionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Deflate (Default)", "SaveStateCompressionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Deflate (High)", "SaveStateCompressionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Zstandard (Low)", "SaveStateCompressionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Zstandard (Default)", "SaveStateCompressionMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Zstandard (High)", "SaveStateCompressionMode"),
};
static_assert(s_save_state_compression_mode_names.size() == static_cast<size_t>(SaveStateCompressionMode::Count));
static_assert(s_save_state_compression_mode_display_names.size() ==
@ -1844,7 +1910,8 @@ const char* Settings::GetSaveStateCompressionModeName(SaveStateCompressionMode m
const char* Settings::GetSaveStateCompressionModeDisplayName(SaveStateCompressionMode mode)
{
return Host::TranslateToCString("Settings", s_save_state_compression_mode_display_names[static_cast<size_t>(mode)]);
return Host::TranslateToCString("Settings", s_save_state_compression_mode_display_names[static_cast<size_t>(mode)],
"SaveStateCompressionMode");
}
std::string EmuFolders::AppRoot;

2
src/duckstation-qt/graphicssettingswidget.cpp
Unescape Escape View File

@ -639,7 +639,7 @@ void GraphicsSettingsWidget::setupAdditionalUi()
for (u32 i = 0; i < static_cast<u32>(ForceVideoTimingMode::Count); i++)
{
m_ui.forceVideoTiming->addItem(
QString::fromUtf8(Settings::GetForceVideoTimingName(static_cast<ForceVideoTimingMode>(i))));
QString::fromUtf8(Settings::GetForceVideoTimingDisplayName(static_cast<ForceVideoTimingMode>(i))));
}
// Advanced Tab

8
src/duckstation-qt/qttranslations.cpp
Unescape Escape View File

@ -156,13 +156,15 @@ QString QtHost::FixLanguageName(const QString& language)
return language;
}
s32 Host::Internal::GetTranslatedStringImpl(std::string_view context, std::string_view msg, char* tbuf,
size_t tbuf_space)
s32 Host::Internal::GetTranslatedStringImpl(std::string_view context, std::string_view msg,
std::string_view disambiguation, char* tbuf, size_t tbuf_space)
{
// This is really awful. Thankfully we're caching the results...
const std::string temp_context(context);
const std::string temp_msg(msg);
const QString translated_msg = qApp->translate(temp_context.c_str(), temp_msg.c_str());
const std::string temp_disambiguation(disambiguation);
const QString translated_msg = qApp->translate(temp_context.c_str(), temp_msg.c_str(),
disambiguation.empty() ? nullptr : temp_disambiguation.c_str());
const QByteArray translated_utf8 = translated_msg.toUtf8();
const size_t translated_size = translated_utf8.size();
if (translated_size > tbuf_space)

2
src/duckstation-qt/translations/create-update-and-edit-language.bat
Unescape Escape View File

@ -66,7 +66,7 @@ REM A good .ts file has been passed
ECHO Updating %filename%...
ECHO.
SET "linguist=..\..\..\dep\msvc\deps-x64\bin"
SET "context=.././ ../../core/ ../../util/ -tr-function-alias QT_TRANSLATE_NOOP+=TRANSLATE,QT_TRANSLATE_NOOP+=TRANSLATE_SV,QT_TRANSLATE_NOOP+=TRANSLATE_STR,QT_TRANSLATE_NOOP+=TRANSLATE_FS,QT_TRANSLATE_N_NOOP3+=TRANSLATE_FMT,QT_TRANSLATE_NOOP+=TRANSLATE_NOOP,translate+=TRANSLATE_PLURAL_STR,translate+=TRANSLATE_PLURAL_SSTR,translate+=TRANSLATE_PLURAL_FS"
SET "context=.././ ../../core/ ../../util/ -tr-function-alias QT_TRANSLATE_NOOP+=TRANSLATE,QT_TRANSLATE_NOOP+=TRANSLATE_SV,QT_TRANSLATE_NOOP+=TRANSLATE_STR,QT_TRANSLATE_NOOP+=TRANSLATE_FS,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_SV,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_STR,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_FS,QT_TRANSLATE_N_NOOP3+=TRANSLATE_FMT,QT_TRANSLATE_NOOP+=TRANSLATE_NOOP,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_NOOP,translate+=TRANSLATE_PLURAL_STR,translate+=TRANSLATE_PLURAL_SSTR,translate+=TRANSLATE_PLURAL_FS"
"%linguist%\lupdate.exe" %context% -ts %filename%
ECHO.

24
src/duckstation-qt/translations/set-language.bat
Unescape Escape View File

@ -1,24 +0,0 @@
@echo off
echo Set your language
echo.
echo Examples:
echo en ^<-- English
echo en-au ^<-- Australian English
echo ^<-- Remove language setting
echo.
echo For the 369-1 2-digit language code
echo https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
echo.
echo If you require a country code as well (you probably don't)
echo https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes
echo.
echo.%lang%
set /p newlang="Enter language code: "
if defined newlang ( setx lang %newlang% )
if defined lang if not defined newlang (
echo Removing language setting...
setx lang "" 1>nul
reg delete HKCU\Environment /F /V lang 2>nul
reg delete "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /F /V lang 2>nul
)
pause

2
src/duckstation-qt/translations/update-and-edit-english.bat
Unescape Escape View File

@ -1,7 +1,7 @@
@echo off
set "linguist=..\..\..\dep\msvc\deps-x64\bin"
set context=../ ../../core/ ../../util/ -tr-function-alias QT_TRANSLATE_NOOP+=TRANSLATE,QT_TRANSLATE_NOOP+=TRANSLATE_SV,QT_TRANSLATE_NOOP+=TRANSLATE_STR,QT_TRANSLATE_NOOP+=TRANSLATE_FS,QT_TRANSLATE_N_NOOP3+=TRANSLATE_FMT,QT_TRANSLATE_NOOP+=TRANSLATE_NOOP,translate+=TRANSLATE_PLURAL_STR,translate+=TRANSLATE_PLURAL_SSTR,translate+=TRANSLATE_PLURAL_FS -pluralonly -no-obsolete
set context=../ ../../core/ ../../util/ -tr-function-alias QT_TRANSLATE_NOOP+=TRANSLATE,QT_TRANSLATE_NOOP+=TRANSLATE_SV,QT_TRANSLATE_NOOP+=TRANSLATE_STR,QT_TRANSLATE_NOOP+=TRANSLATE_FS,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_SV,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_STR,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_FS,QT_TRANSLATE_N_NOOP3+=TRANSLATE_FMT,QT_TRANSLATE_NOOP+=TRANSLATE_NOOP,QT_TRANSLATE_NOOP3+=TRANSLATE_DISAMBIG_NOOP,translate+=TRANSLATE_PLURAL_STR,translate+=TRANSLATE_PLURAL_SSTR,translate+=TRANSLATE_PLURAL_FS -pluralonly -no-obsolete
"%linguist%\lupdate.exe" %context% -ts duckstation-qt_en.ts
pause

12
src/duckstation-qt/translations/update-and-edit-language.bat
Unescape Escape View File

@ -1,12 +0,0 @@
@echo off
if not defined lang (echo Please set your language first & pause & exit)
set "linguist=..\..\..\dep\msvc\deps-x64\bin"
SET "context=.././ ../../core/ ../../util/ -tr-function-alias QT_TRANSLATE_NOOP+=TRANSLATE,QT_TRANSLATE_NOOP+=TRANSLATE_SV,QT_TRANSLATE_NOOP+=TRANSLATE_STR,QT_TRANSLATE_NOOP+=TRANSLATE_FS,QT_TRANSLATE_N_NOOP3+=TRANSLATE_FMT,QT_TRANSLATE_NOOP+=TRANSLATE_NOOP,translate+=TRANSLATE_PLURAL_STR,translate+=TRANSLATE_PLURAL_SSTR,translate+=TRANSLATE_PLURAL_FS"
"%linguist%\lupdate.exe" %context% -noobsolete -ts duckstation-qt_%lang%.ts
pause
cd "%linguist%"
start /B linguist.exe "%~dp0\duckstation-qt_%lang%.ts"

22
src/util/audio_stream.cpp
Unescape Escape View File

@ -210,10 +210,10 @@ static constexpr const std::array s_backend_names = {
#endif
};
static constexpr const std::array s_backend_display_names = {
TRANSLATE_NOOP("AudioStream", "Null (No Output)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Null (No Output)", "AudioBackend"),
#ifndef __ANDROID__
TRANSLATE_NOOP("AudioStream", "Cubeb"),
TRANSLATE_NOOP("AudioStream", "SDL"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Cubeb", "AudioBackend"),
TRANSLATE_DISAMBIG_NOOP("Settings", "SDL", "AudioBackend"),
#else
"AAudio",
"OpenSL ES",
@ -250,26 +250,28 @@ static constexpr const std::array s_stretch_mode_names = {
"TimeStretch",
};
static constexpr const std::array s_stretch_mode_display_names = {
TRANSLATE_NOOP("AudioStream", "Off (Noisy)"),
TRANSLATE_NOOP("AudioStream", "Resampling (Pitch Shift)"),
TRANSLATE_NOOP("AudioStream", "Time Stretch (Tempo Change, Best Sound)"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Off (Noisy)", "AudioStretchMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Resampling (Pitch Shift)", "AudioStretchMode"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Time Stretch (Tempo Change, Best Sound)", "AudioStretchMode"),
};
const char* AudioStream::GetStretchModeName(AudioStretchMode mode)
{
return (static_cast<u32>(mode) < s_stretch_mode_names.size()) ? s_stretch_mode_names[static_cast<u32>(mode)] : "";
return (static_cast<size_t>(mode) < s_stretch_mode_names.size()) ? s_stretch_mode_names[static_cast<size_t>(mode)] :
"";
}
const char* AudioStream::GetStretchModeDisplayName(AudioStretchMode mode)
{
return (static_cast<u32>(mode) < s_stretch_mode_display_names.size()) ?
Host::TranslateToCString("AudioStream", s_stretch_mode_display_names[static_cast<u32>(mode)]) :
return (static_cast<size_t>(mode) < s_stretch_mode_display_names.size()) ?
Host::TranslateToCString("Settings", s_stretch_mode_display_names[static_cast<size_t>(mode)],
"AudioStretchMode") :
"";
}
std::optional<AudioStretchMode> AudioStream::ParseStretchMode(const char* name)
{
for (u8 i = 0; i < static_cast<u8>(AudioStretchMode::Count); i++)
for (size_t i = 0; i < static_cast<u8>(AudioStretchMode::Count); i++)
{
if (std::strcmp(name, s_stretch_mode_names[i]) == 0)
return static_cast<AudioStretchMode>(i);

43
src/util/host.cpp
Unescape Escape View File

@ -14,7 +14,8 @@
Log_SetChannel(Host);
namespace Host {
static std::pair<const char*, u32> LookupTranslationString(std::string_view context, std::string_view msg);
static std::pair<const char*, u32> LookupTranslationString(std::string_view context, std::string_view msg,
std::string_view disambiguation);
static constexpr u32 TRANSLATION_STRING_CACHE_SIZE = 4 * 1024 * 1024;
using TranslationStringMap = PreferUnorderedStringMap<std::pair<u32, u32>>;
@ -25,13 +26,15 @@ static std::vector<char> s_translation_string_cache;
static u32 s_translation_string_cache_pos;
} // namespace Host
std::pair<const char*, u32> Host::LookupTranslationString(std::string_view context, std::string_view msg)
std::pair<const char*, u32> Host::LookupTranslationString(std::string_view context, std::string_view msg,
std::string_view disambiguation)
{
// TODO: TranslatableString, compile-time hashing.
TranslationStringContextMap::iterator ctx_it;
TranslationStringMap::iterator msg_it;
std::pair<const char*, u32> ret;
SmallString disambiguation_key;
s32 len;
// Shouldn't happen, but just in case someone tries to translate an empty string.
@ -42,13 +45,19 @@ std::pair<const char*, u32> Host::LookupTranslationString(std::string_view conte
return ret;
}
if (!disambiguation.empty())
{
disambiguation_key.append(disambiguation);
disambiguation_key.append(msg);
}
s_translation_string_mutex.lock_shared();
ctx_it = s_translation_string_map.find(context);
if (ctx_it == s_translation_string_map.end()) [[unlikely]]
goto add_string;
msg_it = ctx_it->second.find(msg);
msg_it = ctx_it->second.find(disambiguation.empty() ? msg : disambiguation_key.view());
if (msg_it == ctx_it->second.end()) [[unlikely]]
goto add_string;
@ -69,15 +78,15 @@ add_string:
s_translation_string_cache_pos = 0;
}
if ((len =
Internal::GetTranslatedStringImpl(context, msg, &s_translation_string_cache[s_translation_string_cache_pos],
TRANSLATION_STRING_CACHE_SIZE - 1 - s_translation_string_cache_pos)) < 0)
if ((len = Internal::GetTranslatedStringImpl(context, msg, disambiguation,
&s_translation_string_cache[s_translation_string_cache_pos],
TRANSLATION_STRING_CACHE_SIZE - 1 - s_translation_string_cache_pos)) < 0)
{
ERROR_LOG("WARNING: Clearing translation string cache, it might need to be larger.");
s_translation_string_cache_pos = 0;
if ((len =
Internal::GetTranslatedStringImpl(context, msg, &s_translation_string_cache[s_translation_string_cache_pos],
TRANSLATION_STRING_CACHE_SIZE - 1 - s_translation_string_cache_pos)) < 0)
if ((len = Internal::GetTranslatedStringImpl(
context, msg, disambiguation, &s_translation_string_cache[s_translation_string_cache_pos],
TRANSLATION_STRING_CACHE_SIZE - 1 - s_translation_string_cache_pos)) < 0)
{
Panic("Failed to get translated string after clearing cache.");
len = 0;
@ -93,7 +102,8 @@ add_string:
const u32 insert_pos = s_translation_string_cache_pos;
s_translation_string_cache[insert_pos + static_cast<u32>(len)] = 0;
ctx_it->second.emplace(msg, std::pair<u32, u32>(insert_pos, static_cast<u32>(len)));
ctx_it->second.emplace(disambiguation.empty() ? msg : disambiguation_key.view(),
std::pair<u32, u32>(insert_pos, static_cast<u32>(len)));
s_translation_string_cache_pos = insert_pos + static_cast<u32>(len) + 1;
ret.first = &s_translation_string_cache[insert_pos];
@ -102,20 +112,21 @@ add_string:
return ret;
}
const char* Host::TranslateToCString(std::string_view context, std::string_view msg)
const char* Host::TranslateToCString(std::string_view context, std::string_view msg, std::string_view disambiguation)
{
return LookupTranslationString(context, msg).first;
return LookupTranslationString(context, msg, disambiguation).first;
}
std::string_view Host::TranslateToStringView(std::string_view context, std::string_view msg)
std::string_view Host::TranslateToStringView(std::string_view context, std::string_view msg,
std::string_view disambiguation)
{
const auto mp = LookupTranslationString(context, msg);
const auto mp = LookupTranslationString(context, msg, disambiguation);
return std::string_view(mp.first, mp.second);
}
std::string Host::TranslateToString(std::string_view context, std::string_view msg)
std::string Host::TranslateToString(std::string_view context, std::string_view msg, std::string_view disambiguation)
{
return std::string(TranslateToStringView(context, msg));
return std::string(TranslateToStringView(context, msg, disambiguation));
}
void Host::ClearTranslationCache()

16
src/util/host.h
Unescape Escape View File

@ -50,16 +50,17 @@ bool CopyTextToClipboard(std::string_view text);
/// Returns a localized version of the specified string within the specified context.
/// The pointer is guaranteed to be valid until the next language change.
const char* TranslateToCString(std::string_view context, std::string_view msg);
const char* TranslateToCString(std::string_view context, std::string_view msg, std::string_view disambiguation = {});
/// Returns a localized version of the specified string within the specified context.
/// The view is guaranteed to be valid until the next language change.
/// NOTE: When passing this to fmt, positional arguments should be used in the base string, as
/// not all locales follow the same word ordering.
std::string_view TranslateToStringView(std::string_view context, std::string_view msg);
std::string_view TranslateToStringView(std::string_view context, std::string_view msg,
std::string_view disambiguation = {});
/// Returns a localized version of the specified string within the specified context.
std::string TranslateToString(std::string_view context, std::string_view msg);
std::string TranslateToString(std::string_view context, std::string_view msg, std::string_view disambiguation = {});
/// Returns a localized version of the specified string within the specified context, adjusting for plurals using %n.
std::string TranslatePluralToString(const char* context, const char* msg, const char* disambiguation, int count);
@ -70,7 +71,8 @@ void ClearTranslationCache();
namespace Internal {
/// Implementation to retrieve a translated string.
s32 GetTranslatedStringImpl(std::string_view context, std::string_view msg, char* tbuf, size_t tbuf_space);
s32 GetTranslatedStringImpl(std::string_view context, std::string_view msg, std::string_view disambiguation, char* tbuf,
size_t tbuf_space);
} // namespace Internal
} // namespace Host
@ -79,6 +81,11 @@ s32 GetTranslatedStringImpl(std::string_view context, std::string_view msg, char
#define TRANSLATE_SV(context, msg) Host::TranslateToStringView(context, msg)
#define TRANSLATE_STR(context, msg) Host::TranslateToString(context, msg)
#define TRANSLATE_FS(context, msg) fmt::runtime(Host::TranslateToStringView(context, msg))
#define TRANSLATE_DISAMBIG(context, msg, disambiguation) Host::TranslateToCString(context, msg, disambiguation)
#define TRANSLATE_DISAMBIG_SV(context, msg, disambiguation) Host::TranslateToStringView(context, msg, disambiguation)
#define TRANSLATE_DISAMBIG_STR(context, msg, disambiguation) Host::TranslateToString(context, msg, disambiguation)
#define TRANSLATE_DISAMBIG_FS(context, msg, disambiguation) \
fmt::runtime(Host::TranslateToStringView(context, msg, disambiguation))
#define TRANSLATE_PLURAL_STR(context, msg, disambiguation, count) \
Host::TranslatePluralToString(context, msg, disambiguation, count)
#define TRANSLATE_PLURAL_SSTR(context, msg, disambiguation, count) \
@ -88,3 +95,4 @@ s32 GetTranslatedStringImpl(std::string_view context, std::string_view msg, char
// Does not translate the string at runtime, but allows the UI to in its own way.
#define TRANSLATE_NOOP(context, msg) msg
#define TRANSLATE_DISAMBIG_NOOP(context, msg, disambiguation) msg

7
src/util/media_capture.cpp
Unescape Escape View File

@ -2871,10 +2871,10 @@ static constexpr const std::array s_backend_names = {
};
static constexpr const std::array s_backend_display_names = {
#ifdef _WIN32
TRANSLATE_NOOP("MediaCapture", "Media Foundation"),
TRANSLATE_DISAMBIG_NOOP("Settings", "Media Foundation", "MediaCaptureBackend"),
#endif
#ifndef __ANDROID__
TRANSLATE_NOOP("MediaCapture", "FFmpeg"),
TRANSLATE_DISAMBIG_NOOP("Settings", "FFmpeg", "MediaCaptureBackend"),
#endif
};
static_assert(s_backend_names.size() == static_cast<size_t>(MediaCaptureBackend::MaxCount));
@ -2903,7 +2903,8 @@ const char* MediaCapture::GetBackendName(MediaCaptureBackend backend)
const char* MediaCapture::GetBackendDisplayName(MediaCaptureBackend backend)
{
return Host::TranslateToCString("MediaCapture", s_backend_display_names[static_cast<size_t>(backend)]);
return Host::TranslateToCString("Settings", s_backend_display_names[static_cast<size_t>(backend)],
"MediaCaptureBackend");
}
void MediaCapture::AdjustVideoSize(u32* width, u32* height)

Write Preview
Loading…
Cancel
Save