notsoyuzu
/
yuzu-android
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

shared_translation: Call tr for each string 

Qt can't parse tr called within a macro, so we must call it on each
string.

shared_translation: Remove redundant include
This commit is contained in:
lat9nq 2023-11-08 11:25:30 -05:00
parent 940618a64d
commit 71cdfa6ad5
1 changed files with 268 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

499
src/yuzu/configuration/shared_translation.cpp
View File

@ -1,17 +1,18 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "common/time_zone.h"
#include "yuzu/configuration/shared_translation.h" #include "yuzu/configuration/shared_translation.h"
#include <map> #include <map>
#include <memory> #include <memory>
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <QCoreApplication>
#include <QWidget> #include <QWidget>
#include "common/settings.h" #include "common/settings.h"
#include "common/settings_enums.h" #include "common/settings_enums.h"
#include "common/settings_setting.h" #include "common/settings_setting.h"
#include "common/time_zone.h"
#include "yuzu/uisettings.h" #include "yuzu/uisettings.h"
namespace ConfigurationShared { namespace ConfigurationShared {
@ -21,123 +22,135 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); }; const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); };
#define INSERT(SETTINGS, ID, NAME, TOOLTIP) \ #define INSERT(SETTINGS, ID, NAME, TOOLTIP) \
translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{tr((NAME)), tr((TOOLTIP))}}) translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{(NAME), (TOOLTIP)}})
// A setting can be ignored by giving it a blank name // A setting can be ignored by giving it a blank name
// Audio // Audio
INSERT(Settings, sink_id, "Output Engine:", ""); INSERT(Settings, sink_id, tr("Output Engine:"), QStringLiteral());
INSERT(Settings, audio_output_device_id, "Output Device:", ""); INSERT(Settings, audio_output_device_id, tr("Output Device:"), QStringLiteral());
INSERT(Settings, audio_input_device_id, "Input Device:", ""); INSERT(Settings, audio_input_device_id, tr("Input Device:"), QStringLiteral());
INSERT(Settings, audio_muted, "Mute audio", ""); INSERT(Settings, audio_muted, tr("Mute audio"), QStringLiteral());
INSERT(Settings, volume, "Volume:", ""); INSERT(Settings, volume, tr("Volume:"), QStringLiteral());
INSERT(Settings, dump_audio_commands, "", ""); INSERT(Settings, dump_audio_commands, QStringLiteral(), QStringLiteral());
INSERT(UISettings, mute_when_in_background, "Mute audio when in background", ""); INSERT(UISettings, mute_when_in_background, tr("Mute audio when in background"),
QStringLiteral());
// Core // Core
INSERT(Settings, use_multi_core, "Multicore CPU Emulation", ""); INSERT(Settings, use_multi_core, tr("Multicore CPU Emulation"), QStringLiteral());
INSERT(Settings, memory_layout_mode, "Memory Layout", ""); INSERT(Settings, memory_layout_mode, tr("Memory Layout"), QStringLiteral());
INSERT(Settings, use_speed_limit, "", ""); INSERT(Settings, use_speed_limit, QStringLiteral(), QStringLiteral());
INSERT(Settings, speed_limit, "Limit Speed Percent", ""); INSERT(Settings, speed_limit, tr("Limit Speed Percent"), QStringLiteral());
// Cpu // Cpu
INSERT(Settings, cpu_accuracy, "Accuracy:", ""); INSERT(Settings, cpu_accuracy, tr("Accuracy:"), QStringLiteral());
// Cpu Debug // Cpu Debug
// Cpu Unsafe // Cpu Unsafe
INSERT(Settings, cpuopt_unsafe_unfuse_fma,
"Unfuse FMA (improve performance on CPUs without FMA)",
"This option improves speed by reducing accuracy of fused-multiply-add instructions on "
"CPUs without native FMA support.");
INSERT(Settings, cpuopt_unsafe_reduce_fp_error, "Faster FRSQRTE and FRECPE",
"This option improves the speed of some approximate floating-point functions by using "
"less accurate native approximations.");
INSERT(Settings, cpuopt_unsafe_ignore_standard_fpcr, "Faster ASIMD instructions (32 bits only)",
"This option improves the speed of 32 bits ASIMD floating-point functions by running "
"with incorrect rounding modes.");
INSERT(Settings, cpuopt_unsafe_inaccurate_nan, "Inaccurate NaN handling",
"This option improves speed by removing NaN checking. Please note this also reduces "
"accuracy of certain floating-point instructions.");
INSERT( INSERT(
Settings, cpuopt_unsafe_fastmem_check, "Disable address space checks", Settings, cpuopt_unsafe_unfuse_fma,
"This option improves speed by eliminating a safety check before every memory read/write " tr("Unfuse FMA (improve performance on CPUs without FMA)"),
"in guest. Disabling it may allow a game to read/write the emulator's memory."); tr("This option improves speed by reducing accuracy of fused-multiply-add instructions on "
INSERT(Settings, cpuopt_unsafe_ignore_global_monitor, "Ignore global monitor", "CPUs without native FMA support."));
"This option improves speed by relying only on the semantics of cmpxchg to ensure " INSERT(
Settings, cpuopt_unsafe_reduce_fp_error, tr("Faster FRSQRTE and FRECPE"),
tr("This option improves the speed of some approximate floating-point functions by using "
"less accurate native approximations."));
INSERT(Settings, cpuopt_unsafe_ignore_standard_fpcr,
tr("Faster ASIMD instructions (32 bits only)"),
tr("This option improves the speed of 32 bits ASIMD floating-point functions by running "
"with incorrect rounding modes."));
INSERT(Settings, cpuopt_unsafe_inaccurate_nan, tr("Inaccurate NaN handling"),
tr("This option improves speed by removing NaN checking. Please note this also reduces "
"accuracy of certain floating-point instructions."));
INSERT(Settings, cpuopt_unsafe_fastmem_check, tr("Disable address space checks"),
tr("This option improves speed by eliminating a safety check before every memory "
"read/write "
"in guest. Disabling it may allow a game to read/write the emulator's memory."));
INSERT(
Settings, cpuopt_unsafe_ignore_global_monitor, tr("Ignore global monitor"),
tr("This option improves speed by relying only on the semantics of cmpxchg to ensure "
"safety of exclusive access instructions. Please note this may result in deadlocks and " "safety of exclusive access instructions. Please note this may result in deadlocks and "
"other race conditions."); "other race conditions."));
// Renderer // Renderer
INSERT(Settings, renderer_backend, "API:", ""); INSERT(Settings, renderer_backend, tr("API:"), QStringLiteral());
INSERT(Settings, vulkan_device, "Device:", ""); INSERT(Settings, vulkan_device, tr("Device:"), QStringLiteral());
INSERT(Settings, shader_backend, "Shader Backend:", ""); INSERT(Settings, shader_backend, tr("Shader Backend:"), QStringLiteral());
INSERT(Settings, resolution_setup, "Resolution:", ""); INSERT(Settings, resolution_setup, tr("Resolution:"), QStringLiteral());
INSERT(Settings, scaling_filter, "Window Adapting Filter:", ""); INSERT(Settings, scaling_filter, tr("Window Adapting Filter:"), QStringLiteral());
INSERT(Settings, fsr_sharpening_slider, "FSR Sharpness:", ""); INSERT(Settings, fsr_sharpening_slider, tr("FSR Sharpness:"), QStringLiteral());
INSERT(Settings, anti_aliasing, "Anti-Aliasing Method:", ""); INSERT(Settings, anti_aliasing, tr("Anti-Aliasing Method:"), QStringLiteral());
INSERT(Settings, fullscreen_mode, "Fullscreen Mode:", ""); INSERT(Settings, fullscreen_mode, tr("Fullscreen Mode:"), QStringLiteral());
INSERT(Settings, aspect_ratio, "Aspect Ratio:", ""); INSERT(Settings, aspect_ratio, tr("Aspect Ratio:"), QStringLiteral());
INSERT(Settings, use_disk_shader_cache, "Use disk pipeline cache", ""); INSERT(Settings, use_disk_shader_cache, tr("Use disk pipeline cache"), QStringLiteral());
INSERT(Settings, use_asynchronous_gpu_emulation, "Use asynchronous GPU emulation", ""); INSERT(Settings, use_asynchronous_gpu_emulation, tr("Use asynchronous GPU emulation"),
INSERT(Settings, nvdec_emulation, "NVDEC emulation:", ""); QStringLiteral());
INSERT(Settings, accelerate_astc, "ASTC Decoding Method:", ""); INSERT(Settings, nvdec_emulation, tr("NVDEC emulation:"), QStringLiteral());
INSERT(Settings, astc_recompression, "ASTC Recompression Method:", ""); INSERT(Settings, accelerate_astc, tr("ASTC Decoding Method:"), QStringLiteral());
INSERT(Settings, vsync_mode, "VSync Mode:", INSERT(Settings, astc_recompression, tr("ASTC Recompression Method:"), QStringLiteral());
"FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen " INSERT(
Settings, vsync_mode, tr("VSync Mode:"),
tr("FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen "
"refresh rate.\nFIFO Relaxed is similar to FIFO but allows tearing as it recovers from " "refresh rate.\nFIFO Relaxed is similar to FIFO but allows tearing as it recovers from "
"a slow down.\nMailbox can have lower latency than FIFO and does not tear but may drop " "a slow down.\nMailbox can have lower latency than FIFO and does not tear but may drop "
"frames.\nImmediate (no synchronization) just presents whatever is available and can " "frames.\nImmediate (no synchronization) just presents whatever is available and can "
"exhibit tearing."); "exhibit tearing."));
INSERT(Settings, bg_red, "", ""); INSERT(Settings, bg_red, QStringLiteral(), QStringLiteral());
INSERT(Settings, bg_green, "", ""); INSERT(Settings, bg_green, QStringLiteral(), QStringLiteral());
INSERT(Settings, bg_blue, "", ""); INSERT(Settings, bg_blue, QStringLiteral(), QStringLiteral());
// Renderer (Advanced Graphics) // Renderer (Advanced Graphics)
INSERT(Settings, async_presentation, "Enable asynchronous presentation (Vulkan only)", ""); INSERT(Settings, async_presentation, tr("Enable asynchronous presentation (Vulkan only)"),
INSERT(Settings, renderer_force_max_clock, "Force maximum clocks (Vulkan only)", QStringLiteral());
"Runs work in the background while waiting for graphics commands to keep the GPU from " INSERT(
"lowering its clock speed."); Settings, renderer_force_max_clock, tr("Force maximum clocks (Vulkan only)"),
INSERT(Settings, max_anisotropy, "Anisotropic Filtering:", ""); tr("Runs work in the background while waiting for graphics commands to keep the GPU from "
INSERT(Settings, gpu_accuracy, "Accuracy Level:", ""); "lowering its clock speed."));
INSERT(Settings, use_asynchronous_shaders, "Use asynchronous shader building (Hack)", INSERT(Settings, max_anisotropy, tr("Anisotropic Filtering:"), QStringLiteral());
"Enables asynchronous shader compilation, which may reduce shader stutter. This feature " INSERT(Settings, gpu_accuracy, tr("Accuracy Level:"), QStringLiteral());
"is experimental."); INSERT(
INSERT(Settings, use_fast_gpu_time, "Use Fast GPU Time (Hack)", Settings, use_asynchronous_shaders, tr("Use asynchronous shader building (Hack)"),
"Enables Fast GPU Time. This option will force most games to run at their highest " tr("Enables asynchronous shader compilation, which may reduce shader stutter. This feature "
"native resolution."); "is experimental."));
INSERT(Settings, use_vulkan_driver_pipeline_cache, "Use Vulkan pipeline cache", INSERT(Settings, use_fast_gpu_time, tr("Use Fast GPU Time (Hack)"),
"Enables GPU vendor-specific pipeline cache. This option can improve shader loading " tr("Enables Fast GPU Time. This option will force most games to run at their highest "
"native resolution."));
INSERT(Settings, use_vulkan_driver_pipeline_cache, tr("Use Vulkan pipeline cache"),
tr("Enables GPU vendor-specific pipeline cache. This option can improve shader loading "
"time significantly in cases where the Vulkan driver does not store pipeline cache " "time significantly in cases where the Vulkan driver does not store pipeline cache "
"files internally."); "files internally."));
INSERT(Settings, enable_compute_pipelines, "Enable Compute Pipelines (Intel Vulkan Only)", INSERT(
"Enable compute pipelines, required by some games.\nThis setting only exists for Intel " Settings, enable_compute_pipelines, tr("Enable Compute Pipelines (Intel Vulkan Only)"),
tr("Enable compute pipelines, required by some games.\nThis setting only exists for Intel "
"proprietary drivers, and may crash if enabled.\nCompute pipelines are always enabled " "proprietary drivers, and may crash if enabled.\nCompute pipelines are always enabled "
"on all other drivers."); "on all other drivers."));
INSERT(Settings, use_reactive_flushing, "Enable Reactive Flushing", INSERT(
"Uses reactive flushing instead of predictive flushing, allowing more accurate memory " Settings, use_reactive_flushing, tr("Enable Reactive Flushing"),
"syncing."); tr("Uses reactive flushing instead of predictive flushing, allowing more accurate memory "
INSERT(Settings, use_video_framerate, "Sync to framerate of video playback", "syncing."));
"Run the game at normal speed during video playback, even when the framerate is " INSERT(Settings, use_video_framerate, tr("Sync to framerate of video playback"),
"unlocked."); tr("Run the game at normal speed during video playback, even when the framerate is "
INSERT(Settings, barrier_feedback_loops, "Barrier feedback loops", "unlocked."));
"Improves rendering of transparency effects in specific games."); INSERT(Settings, barrier_feedback_loops, tr("Barrier feedback loops"),
tr("Improves rendering of transparency effects in specific games."));
// Renderer (Debug) // Renderer (Debug)
// System // System
INSERT(Settings, rng_seed, "RNG Seed", ""); INSERT(Settings, rng_seed, tr("RNG Seed"), QStringLiteral());
INSERT(Settings, rng_seed_enabled, "", ""); INSERT(Settings, rng_seed_enabled, QStringLiteral(), QStringLiteral());
INSERT(Settings, device_name, "Device Name", ""); INSERT(Settings, device_name, tr("Device Name"), QStringLiteral());
INSERT(Settings, custom_rtc, "Custom RTC", ""); INSERT(Settings, custom_rtc, tr("Custom RTC"), QStringLiteral());
INSERT(Settings, custom_rtc_enabled, "", ""); INSERT(Settings, custom_rtc_enabled, QStringLiteral(), QStringLiteral());
INSERT(Settings, language_index, INSERT(Settings, language_index, tr("Language:"),
"Language:", "Note: this can be overridden when region setting is auto-select"); tr("Note: this can be overridden when region setting is auto-select"));
INSERT(Settings, region_index, "Region:", ""); INSERT(Settings, region_index, tr("Region:"), QStringLiteral());
INSERT(Settings, time_zone_index, "Time Zone:", ""); INSERT(Settings, time_zone_index, tr("Time Zone:"), QStringLiteral());
INSERT(Settings, sound_index, "Sound Output Mode:", ""); INSERT(Settings, sound_index, tr("Sound Output Mode:"), QStringLiteral());
INSERT(Settings, use_docked_mode, "Console Mode:", ""); INSERT(Settings, use_docked_mode, tr("Console Mode:"), QStringLiteral());
INSERT(Settings, current_user, "", ""); INSERT(Settings, current_user, QStringLiteral(), QStringLiteral());
// Controls // Controls
@ -154,11 +167,14 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
// Ui // Ui
// Ui General // Ui General
INSERT(UISettings, select_user_on_boot, "Prompt for user on game boot", ""); INSERT(UISettings, select_user_on_boot, tr("Prompt for user on game boot"), QStringLiteral());
INSERT(UISettings, pause_when_in_background, "Pause emulation when in background", ""); INSERT(UISettings, pause_when_in_background, tr("Pause emulation when in background"),
INSERT(UISettings, confirm_before_stopping, "Confirm before stopping emulation", ""); QStringLiteral());
INSERT(UISettings, hide_mouse, "Hide mouse on inactivity", ""); INSERT(UISettings, confirm_before_stopping, tr("Confirm before stopping emulation"),
INSERT(UISettings, controller_applet_disabled, "Disable controller applet", ""); QStringLiteral());
INSERT(UISettings, hide_mouse, tr("Hide mouse on inactivity"), QStringLiteral());
INSERT(UISettings, controller_applet_disabled, tr("Disable controller applet"),
QStringLiteral());
// Ui Debugging // Ui Debugging
@ -178,140 +194,141 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
return parent->tr(text, context); return parent->tr(text, context);
}; };
#define PAIR(ENUM, VALUE, TRANSLATION) \ #define PAIR(ENUM, VALUE, TRANSLATION) {static_cast<u32>(Settings::ENUM::VALUE), (TRANSLATION)}
{ static_cast<u32>(Settings::ENUM::VALUE), tr(TRANSLATION) }
#define CTX_PAIR(ENUM, VALUE, TRANSLATION, CONTEXT) \
{ static_cast<u32>(Settings::ENUM::VALUE), tr(TRANSLATION, CONTEXT) }
// Intentionally skipping VSyncMode to let the UI fill that one out // Intentionally skipping VSyncMode to let the UI fill that one out
translations->insert({Settings::EnumMetadata<Settings::AstcDecodeMode>::Index(), translations->insert({Settings::EnumMetadata<Settings::AstcDecodeMode>::Index(),
{ {
PAIR(AstcDecodeMode, Cpu, "CPU"), PAIR(AstcDecodeMode, Cpu, tr("CPU")),
PAIR(AstcDecodeMode, Gpu, "GPU"), PAIR(AstcDecodeMode, Gpu, tr("GPU")),
PAIR(AstcDecodeMode, CpuAsynchronous, "CPU Asynchronous"), PAIR(AstcDecodeMode, CpuAsynchronous, tr("CPU Asynchronous")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::AstcRecompression>::Index(), translations->insert(
{Settings::EnumMetadata<Settings::AstcRecompression>::Index(),
{ {
PAIR(AstcRecompression, Uncompressed, "Uncompressed (Best quality)"), PAIR(AstcRecompression, Uncompressed, tr("Uncompressed (Best quality)")),
PAIR(AstcRecompression, Bc1, "BC1 (Low quality)"), PAIR(AstcRecompression, Bc1, tr("BC1 (Low quality)")),
PAIR(AstcRecompression, Bc3, "BC3 (Medium quality)"), PAIR(AstcRecompression, Bc3, tr("BC3 (Medium quality)")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::RendererBackend>::Index(), translations->insert({Settings::EnumMetadata<Settings::RendererBackend>::Index(),
{ {
#ifdef HAS_OPENGL #ifdef HAS_OPENGL
PAIR(RendererBackend, OpenGL, "OpenGL"), PAIR(RendererBackend, OpenGL, tr("OpenGL")),
#endif #endif
PAIR(RendererBackend, Vulkan, "Vulkan"), PAIR(RendererBackend, Vulkan, tr("Vulkan")),
PAIR(RendererBackend, Null, "Null"), PAIR(RendererBackend, Null, tr("Null")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::ShaderBackend>::Index(), translations->insert(
{Settings::EnumMetadata<Settings::ShaderBackend>::Index(),
{ {
PAIR(ShaderBackend, Glsl, "GLSL"), PAIR(ShaderBackend, Glsl, tr("GLSL")),
PAIR(ShaderBackend, Glasm, "GLASM (Assembly Shaders, NVIDIA Only)"), PAIR(ShaderBackend, Glasm, tr("GLASM (Assembly Shaders, NVIDIA Only)")),
PAIR(ShaderBackend, SpirV, "SPIR-V (Experimental, Mesa Only)"), PAIR(ShaderBackend, SpirV, tr("SPIR-V (Experimental, Mesa Only)")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::GpuAccuracy>::Index(), translations->insert({Settings::EnumMetadata<Settings::GpuAccuracy>::Index(),
{ {
PAIR(GpuAccuracy, Normal, "Normal"), PAIR(GpuAccuracy, Normal, tr("Normal")),
PAIR(GpuAccuracy, High, "High"), PAIR(GpuAccuracy, High, tr("High")),
PAIR(GpuAccuracy, Extreme, "Extreme"), PAIR(GpuAccuracy, Extreme, tr("Extreme")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::CpuAccuracy>::Index(), translations->insert(
{Settings::EnumMetadata<Settings::CpuAccuracy>::Index(),
{ {
PAIR(CpuAccuracy, Auto, "Auto"), PAIR(CpuAccuracy, Auto, tr("Auto")),
PAIR(CpuAccuracy, Accurate, "Accurate"), PAIR(CpuAccuracy, Accurate, tr("Accurate")),
PAIR(CpuAccuracy, Unsafe, "Unsafe"), PAIR(CpuAccuracy, Unsafe, tr("Unsafe")),
PAIR(CpuAccuracy, Paranoid, "Paranoid (disables most optimizations)"), PAIR(CpuAccuracy, Paranoid, tr("Paranoid (disables most optimizations)")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::FullscreenMode>::Index(), translations->insert({Settings::EnumMetadata<Settings::FullscreenMode>::Index(),
{ {
PAIR(FullscreenMode, Borderless, "Borderless Windowed"), PAIR(FullscreenMode, Borderless, tr("Borderless Windowed")),
PAIR(FullscreenMode, Exclusive, "Exclusive Fullscreen"), PAIR(FullscreenMode, Exclusive, tr("Exclusive Fullscreen")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::NvdecEmulation>::Index(), translations->insert({Settings::EnumMetadata<Settings::NvdecEmulation>::Index(),
{ {
PAIR(NvdecEmulation, Off, "No Video Output"), PAIR(NvdecEmulation, Off, tr("No Video Output")),
PAIR(NvdecEmulation, Cpu, "CPU Video Decoding"), PAIR(NvdecEmulation, Cpu, tr("CPU Video Decoding")),
PAIR(NvdecEmulation, Gpu, "GPU Video Decoding (Default)"), PAIR(NvdecEmulation, Gpu, tr("GPU Video Decoding (Default)")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::ResolutionSetup>::Index(), translations->insert(
{Settings::EnumMetadata<Settings::ResolutionSetup>::Index(),
{ {
PAIR(ResolutionSetup, Res1_2X, "0.5X (360p/540p) [EXPERIMENTAL]"), PAIR(ResolutionSetup, Res1_2X, tr("0.5X (360p/540p) [EXPERIMENTAL]")),
PAIR(ResolutionSetup, Res3_4X, "0.75X (540p/810p) [EXPERIMENTAL]"), PAIR(ResolutionSetup, Res3_4X, tr("0.75X (540p/810p) [EXPERIMENTAL]")),
PAIR(ResolutionSetup, Res1X, "1X (720p/1080p)"), PAIR(ResolutionSetup, Res1X, tr("1X (720p/1080p)")),
PAIR(ResolutionSetup, Res3_2X, "1.5X (1080p/1620p) [EXPERIMENTAL]"), PAIR(ResolutionSetup, Res3_2X, tr("1.5X (1080p/1620p) [EXPERIMENTAL]")),
PAIR(ResolutionSetup, Res2X, "2X (1440p/2160p)"), PAIR(ResolutionSetup, Res2X, tr("2X (1440p/2160p)")),
PAIR(ResolutionSetup, Res3X, "3X (2160p/3240p)"), PAIR(ResolutionSetup, Res3X, tr("3X (2160p/3240p)")),
PAIR(ResolutionSetup, Res4X, "4X (2880p/4320p)"), PAIR(ResolutionSetup, Res4X, tr("4X (2880p/4320p)")),
PAIR(ResolutionSetup, Res5X, "5X (3600p/5400p)"), PAIR(ResolutionSetup, Res5X, tr("5X (3600p/5400p)")),
PAIR(ResolutionSetup, Res6X, "6X (4320p/6480p)"), PAIR(ResolutionSetup, Res6X, tr("6X (4320p/6480p)")),
PAIR(ResolutionSetup, Res7X, "7X (5040p/7560p)"), PAIR(ResolutionSetup, Res7X, tr("7X (5040p/7560p)")),
PAIR(ResolutionSetup, Res8X, "8X (5760p/8640p)"), PAIR(ResolutionSetup, Res8X, tr("8X (5760p/8640p)")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::ScalingFilter>::Index(), translations->insert({Settings::EnumMetadata<Settings::ScalingFilter>::Index(),
{ {
PAIR(ScalingFilter, NearestNeighbor, "Nearest Neighbor"), PAIR(ScalingFilter, NearestNeighbor, tr("Nearest Neighbor")),
PAIR(ScalingFilter, Bilinear, "Bilinear"), PAIR(ScalingFilter, Bilinear, tr("Bilinear")),
PAIR(ScalingFilter, Bicubic, "Bicubic"), PAIR(ScalingFilter, Bicubic, tr("Bicubic")),
PAIR(ScalingFilter, Gaussian, "Gaussian"), PAIR(ScalingFilter, Gaussian, tr("Gaussian")),
PAIR(ScalingFilter, ScaleForce, "ScaleForce"), PAIR(ScalingFilter, ScaleForce, tr("ScaleForce")),
PAIR(ScalingFilter, Fsr, "AMD FidelityFX™️ Super Resolution"), PAIR(ScalingFilter, Fsr, tr("AMD FidelityFX™️ Super Resolution")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::AntiAliasing>::Index(), translations->insert({Settings::EnumMetadata<Settings::AntiAliasing>::Index(),
{ {
PAIR(AntiAliasing, None, "None"), PAIR(AntiAliasing, None, tr("None")),
PAIR(AntiAliasing, Fxaa, "FXAA"), PAIR(AntiAliasing, Fxaa, tr("FXAA")),
PAIR(AntiAliasing, Smaa, "SMAA"), PAIR(AntiAliasing, Smaa, tr("SMAA")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::AspectRatio>::Index(), translations->insert({Settings::EnumMetadata<Settings::AspectRatio>::Index(),
{ {
PAIR(AspectRatio, R16_9, "Default (16:9)"), PAIR(AspectRatio, R16_9, tr("Default (16:9)")),
PAIR(AspectRatio, R4_3, "Force 4:3"), PAIR(AspectRatio, R4_3, tr("Force 4:3")),
PAIR(AspectRatio, R21_9, "Force 21:9"), PAIR(AspectRatio, R21_9, tr("Force 21:9")),
PAIR(AspectRatio, R16_10, "Force 16:10"), PAIR(AspectRatio, R16_10, tr("Force 16:10")),
PAIR(AspectRatio, Stretch, "Stretch to Window"), PAIR(AspectRatio, Stretch, tr("Stretch to Window")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::AnisotropyMode>::Index(), translations->insert({Settings::EnumMetadata<Settings::AnisotropyMode>::Index(),
{ {
PAIR(AnisotropyMode, Automatic, "Automatic"), PAIR(AnisotropyMode, Automatic, tr("Automatic")),
PAIR(AnisotropyMode, Default, "Default"), PAIR(AnisotropyMode, Default, tr("Default")),
PAIR(AnisotropyMode, X2, "2x"), PAIR(AnisotropyMode, X2, tr("2x")),
PAIR(AnisotropyMode, X4, "4x"), PAIR(AnisotropyMode, X4, tr("4x")),
PAIR(AnisotropyMode, X8, "8x"), PAIR(AnisotropyMode, X8, tr("8x")),
PAIR(AnisotropyMode, X16, "16x"), PAIR(AnisotropyMode, X16, tr("16x")),
}}); }});
translations->insert( translations->insert(
{Settings::EnumMetadata<Settings::Language>::Index(), {Settings::EnumMetadata<Settings::Language>::Index(),
{ {
PAIR(Language, Japanese, "Japanese (日本語)"), PAIR(Language, Japanese, tr("Japanese (日本語)")),
PAIR(Language, EnglishAmerican, "American English"), PAIR(Language, EnglishAmerican, tr("American English")),
PAIR(Language, French, "French (français)"), PAIR(Language, French, tr("French (français)")),
PAIR(Language, German, "German (Deutsch)"), PAIR(Language, German, tr("German (Deutsch)")),
PAIR(Language, Italian, "Italian (italiano)"), PAIR(Language, Italian, tr("Italian (italiano)")),
PAIR(Language, Spanish, "Spanish (español)"), PAIR(Language, Spanish, tr("Spanish (español)")),
PAIR(Language, Chinese, "Chinese"), PAIR(Language, Chinese, tr("Chinese")),
PAIR(Language, Korean, "Korean (한국어)"), PAIR(Language, Korean, tr("Korean (한국어)")),
PAIR(Language, Dutch, "Dutch (Nederlands)"), PAIR(Language, Dutch, tr("Dutch (Nederlands)")),
PAIR(Language, Portuguese, "Portuguese (português)"), PAIR(Language, Portuguese, tr("Portuguese (português)")),
PAIR(Language, Russian, "Russian (Русский)"), PAIR(Language, Russian, tr("Russian (Русский)")),
PAIR(Language, Taiwanese, "Taiwanese"), PAIR(Language, Taiwanese, tr("Taiwanese")),
PAIR(Language, EnglishBritish, "British English"), PAIR(Language, EnglishBritish, tr("British English")),
PAIR(Language, FrenchCanadian, "Canadian French"), PAIR(Language, FrenchCanadian, tr("Canadian French")),
PAIR(Language, SpanishLatin, "Latin American Spanish"), PAIR(Language, SpanishLatin, tr("Latin American Spanish")),
PAIR(Language, ChineseSimplified, "Simplified Chinese"), PAIR(Language, ChineseSimplified, tr("Simplified Chinese")),
PAIR(Language, ChineseTraditional, "Traditional Chinese (正體中文)"), PAIR(Language, ChineseTraditional, tr("Traditional Chinese (正體中文)")),
PAIR(Language, PortugueseBrazilian, "Brazilian Portuguese (português do Brasil)"), PAIR(Language, PortugueseBrazilian, tr("Brazilian Portuguese (português do Brasil)")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::Region>::Index(), translations->insert({Settings::EnumMetadata<Settings::Region>::Index(),
{ {
PAIR(Region, Japan, "Japan"), PAIR(Region, Japan, tr("Japan")),
PAIR(Region, Usa, "USA"), PAIR(Region, Usa, tr("USA")),
PAIR(Region, Europe, "Europe"), PAIR(Region, Europe, tr("Europe")),
PAIR(Region, Australia, "Australia"), PAIR(Region, Australia, tr("Australia")),
PAIR(Region, China, "China"), PAIR(Region, China, tr("China")),
PAIR(Region, Korea, "Korea"), PAIR(Region, Korea, tr("Korea")),
PAIR(Region, Taiwan, "Taiwan"), PAIR(Region, Taiwan, tr("Taiwan")),
}}); }});
translations->insert( translations->insert(
{Settings::EnumMetadata<Settings::TimeZone>::Index(), {Settings::EnumMetadata<Settings::TimeZone>::Index(),
@ -323,72 +340,74 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
{static_cast<u32>(Settings::TimeZone::Default), {static_cast<u32>(Settings::TimeZone::Default),
tr("Default (%1)", "Default time zone") tr("Default (%1)", "Default time zone")
.arg(QString::fromStdString(Common::TimeZone::GetDefaultTimeZone()))}, .arg(QString::fromStdString(Common::TimeZone::GetDefaultTimeZone()))},
PAIR(TimeZone, Cet, "CET"), PAIR(TimeZone, Cet, tr("CET")),
PAIR(TimeZone, Cst6Cdt, "CST6CDT"), PAIR(TimeZone, Cst6Cdt, tr("CST6CDT")),
PAIR(TimeZone, Cuba, "Cuba"), PAIR(TimeZone, Cuba, tr("Cuba")),
PAIR(TimeZone, Eet, "EET"), PAIR(TimeZone, Eet, tr("EET")),
PAIR(TimeZone, Egypt, "Egypt"), PAIR(TimeZone, Egypt, tr("Egypt")),
PAIR(TimeZone, Eire, "Eire"), PAIR(TimeZone, Eire, tr("Eire")),
PAIR(TimeZone, Est, "EST"), PAIR(TimeZone, Est, tr("EST")),
PAIR(TimeZone, Est5Edt, "EST5EDT"), PAIR(TimeZone, Est5Edt, tr("EST5EDT")),
PAIR(TimeZone, Gb, "GB"), PAIR(TimeZone, Gb, tr("GB")),
PAIR(TimeZone, GbEire, "GB-Eire"), PAIR(TimeZone, GbEire, tr("GB-Eire")),
PAIR(TimeZone, Gmt, "GMT"), PAIR(TimeZone, Gmt, tr("GMT")),
PAIR(TimeZone, GmtPlusZero, "GMT+0"), PAIR(TimeZone, GmtPlusZero, tr("GMT+0")),
PAIR(TimeZone, GmtMinusZero, "GMT-0"), PAIR(TimeZone, GmtMinusZero, tr("GMT-0")),
PAIR(TimeZone, GmtZero, "GMT0"), PAIR(TimeZone, GmtZero, tr("GMT0")),
PAIR(TimeZone, Greenwich, "Greenwich"), PAIR(TimeZone, Greenwich, tr("Greenwich")),
PAIR(TimeZone, Hongkong, "Hongkong"), PAIR(TimeZone, Hongkong, tr("Hongkong")),
PAIR(TimeZone, Hst, "HST"), PAIR(TimeZone, Hst, tr("HST")),
PAIR(TimeZone, Iceland, "Iceland"), PAIR(TimeZone, Iceland, tr("Iceland")),
PAIR(TimeZone, Iran, "Iran"), PAIR(TimeZone, Iran, tr("Iran")),
PAIR(TimeZone, Israel, "Israel"), PAIR(TimeZone, Israel, tr("Israel")),
PAIR(TimeZone, Jamaica, "Jamaica"), PAIR(TimeZone, Jamaica, tr("Jamaica")),
PAIR(TimeZone, Japan, "Japan"), PAIR(TimeZone, Japan, tr("Japan")),
PAIR(TimeZone, Kwajalein, "Kwajalein"), PAIR(TimeZone, Kwajalein, tr("Kwajalein")),
PAIR(TimeZone, Libya, "Libya"), PAIR(TimeZone, Libya, tr("Libya")),
PAIR(TimeZone, Met, "MET"), PAIR(TimeZone, Met, tr("MET")),
PAIR(TimeZone, Mst, "MST"), PAIR(TimeZone, Mst, tr("MST")),
PAIR(TimeZone, Mst7Mdt, "MST7MDT"), PAIR(TimeZone, Mst7Mdt, tr("MST7MDT")),
PAIR(TimeZone, Navajo, "Navajo"), PAIR(TimeZone, Navajo, tr("Navajo")),
PAIR(TimeZone, Nz, "NZ"), PAIR(TimeZone, Nz, tr("NZ")),
PAIR(TimeZone, NzChat, "NZ-CHAT"), PAIR(TimeZone, NzChat, tr("NZ-CHAT")),
PAIR(TimeZone, Poland, "Poland"), PAIR(TimeZone, Poland, tr("Poland")),
PAIR(TimeZone, Portugal, "Portugal"), PAIR(TimeZone, Portugal, tr("Portugal")),
PAIR(TimeZone, Prc, "PRC"), PAIR(TimeZone, Prc, tr("PRC")),
PAIR(TimeZone, Pst8Pdt, "PST8PDT"), PAIR(TimeZone, Pst8Pdt, tr("PST8PDT")),
PAIR(TimeZone, Roc, "ROC"), PAIR(TimeZone, Roc, tr("ROC")),
PAIR(TimeZone, Rok, "ROK"), PAIR(TimeZone, Rok, tr("ROK")),
PAIR(TimeZone, Singapore, "Singapore"), PAIR(TimeZone, Singapore, tr("Singapore")),
PAIR(TimeZone, Turkey, "Turkey"), PAIR(TimeZone, Turkey, tr("Turkey")),
PAIR(TimeZone, Uct, "UCT"), PAIR(TimeZone, Uct, tr("UCT")),
PAIR(TimeZone, Universal, "Universal"), PAIR(TimeZone, Universal, tr("Universal")),
PAIR(TimeZone, Utc, "UTC"), PAIR(TimeZone, Utc, tr("UTC")),
PAIR(TimeZone, WSu, "W-SU"), PAIR(TimeZone, WSu, tr("W-SU")),
PAIR(TimeZone, Wet, "WET"), PAIR(TimeZone, Wet, tr("WET")),
PAIR(TimeZone, Zulu, "Zulu"), PAIR(TimeZone, Zulu, tr("Zulu")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::AudioMode>::Index(), translations->insert({Settings::EnumMetadata<Settings::AudioMode>::Index(),
{ {
PAIR(AudioMode, Mono, "Mono"), PAIR(AudioMode, Mono, tr("Mono")),
PAIR(AudioMode, Stereo, "Stereo"), PAIR(AudioMode, Stereo, tr("Stereo")),
PAIR(AudioMode, Surround, "Surround"), PAIR(AudioMode, Surround, tr("Surround")),
}}); }});
translations->insert({Settings::EnumMetadata<Settings::MemoryLayout>::Index(), translations->insert({Settings::EnumMetadata<Settings::MemoryLayout>::Index(),
{ {
PAIR(MemoryLayout, Memory_4Gb, "4GB DRAM (Default)"), PAIR(MemoryLayout, Memory_4Gb, tr("4GB DRAM (Default)")),
PAIR(MemoryLayout, Memory_6Gb, "6GB DRAM (Unsafe)"), PAIR(MemoryLayout, Memory_6Gb, tr("6GB DRAM (Unsafe)")),
PAIR(MemoryLayout, Memory_8Gb, "8GB DRAM (Unsafe)"), PAIR(MemoryLayout, Memory_8Gb, tr("8GB DRAM (Unsafe)")),
}});
translations->insert({Settings::EnumMetadata<Settings::ConsoleMode>::Index(),
{
PAIR(ConsoleMode, Docked, tr("Docked")),
PAIR(ConsoleMode, Handheld, tr("Handheld")),
}}); }});
translations->insert(
{Settings::EnumMetadata<Settings::ConsoleMode>::Index(),
{PAIR(ConsoleMode, Docked, "Docked"), PAIR(ConsoleMode, Handheld, "Handheld")}});
translations->insert( translations->insert(
{Settings::EnumMetadata<Settings::ConfirmStop>::Index(), {Settings::EnumMetadata<Settings::ConfirmStop>::Index(),
{ {
PAIR(ConfirmStop, Ask_Always, "Always ask (Default)"), PAIR(ConfirmStop, Ask_Always, tr("Always ask (Default)")),
PAIR(ConfirmStop, Ask_Based_On_Game, "Only if game specifies not to stop"), PAIR(ConfirmStop, Ask_Based_On_Game, tr("Only if game specifies not to stop")),
PAIR(ConfirmStop, Ask_Never, "Never ask"), PAIR(ConfirmStop, Ask_Never, tr("Never ask")),
}}); }});
#undef PAIR #undef PAIR