using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Globalization;
|
using System.IO;
|
using System.Linq;
|
using System.Runtime.CompilerServices;
|
using System.Xml.Serialization;
|
|
namespace OpenTap.Translation;
|
|
/// <summary>
|
/// Functions for working with translations
|
/// </summary>
|
public static class TranslationManager
|
{
|
private static readonly ITranslator Translator = new Translator();
|
|
internal static string CultureAsString(CultureInfo culture)
|
{
|
if (CultureInfo.InvariantCulture.Equals(culture)) return "Neutral";
|
return $"{culture.NativeName} ({culture.EnglishName})";
|
}
|
|
/// <summary>
|
/// The default language.
|
/// </summary>
|
[Browsable(false)]
|
[XmlIgnore]
|
internal static CultureInfo NeutralLanguage => CultureInfo.InvariantCulture;
|
|
/// <summary>
|
/// The list of languages supported by installed resource files.
|
/// </summary>
|
public static IEnumerable<CultureInfo> SupportedLanguages => Translator.SupportedLanguages;
|
|
/// <summary>
|
/// Get an appropriate DisplayAttribute for the specified reflection data in the requested language.
|
/// </summary>
|
/// <param name="mem"></param>
|
/// <param name="language"></param>
|
/// <returns></returns>
|
public static DisplayAttribute TranslateMember(IReflectionData mem, CultureInfo language = null)
|
{
|
return Translator.TranslateMember(mem, language ?? EngineSettings.Current.Language);
|
}
|
|
/// <summary>
|
/// Get an appropriate DisplayAttribute for the specified enum in the requested language.
|
/// </summary>
|
/// <param name="e"></param>
|
/// <param name="language"></param>
|
/// <returns></returns>
|
public static DisplayAttribute TranslateEnum(Enum e, CultureInfo language = null)
|
{
|
return Translator.TranslateEnum(e, language ?? EngineSettings.Current.Language);
|
}
|
|
/// <summary>
|
/// The directory containing translation resource files.
|
/// </summary>
|
public static string TranslationDirectory => Path.Combine(ExecutorClient.ExeDir, "Languages");
|
|
/// <summary>
|
/// Get an appropriate DisplayAttribute for the specified enum in the requested language.
|
/// </summary>
|
/// <param name="key"></param>
|
/// <param name="language"></param>
|
/// <returns></returns>
|
public static string TranslateKey(string key, CultureInfo language = null)
|
{
|
return Translator.TranslateString(key, language ?? EngineSettings.Current.Language);
|
}
|
|
/// <summary>
|
/// Look for a translated version of the input member and validate the format parameters.
|
/// If no translation is found, or the parameter count does not match, return the neutral string.
|
/// </summary>
|
/// <param name="stringLocalizer">The string localizer which owns the translated string.</param>
|
/// <param name="neutral">The neutral (non-translated) string.</param>
|
/// <param name="key">Lookup key for finding the translation.</param>
|
/// <param name="language">The desired translation language</param>
|
/// <returns>The translated string, if a translation exists, and the string format parameters in the translated string matches the source string. Otherwise, returns the neutral string.</returns>
|
public static FormatString TranslateFormat(this IStringLocalizer stringLocalizer, string neutral,
|
[CallerMemberName] string key = null,
|
CultureInfo language = null)
|
{
|
var translated = Translate(stringLocalizer, neutral, key, language);
|
if (!ReferenceEquals(neutral, translated))
|
{
|
var c1 = CountTemplates(neutral);
|
var c2 = CountTemplates(translated);
|
if (c1 != c2)
|
{
|
log.ErrorOnce(neutral, $"Template parameter count mismatch detected.\n" +
|
$"'{neutral}' has {c1} template parameters.\n" +
|
$"'{translated}' has {c2} template parameters.\n" +
|
$"The first string will be preferred over the second string.");
|
// Use neutral string instead
|
return new FormatString(neutral);
|
}
|
}
|
|
return new FormatString(translated);
|
}
|
|
/// <summary>
|
/// Look for a translated version of the input member. If no translation is found, return the neutral string.
|
/// </summary>
|
/// <param name="stringLocalizer">The string localizer which owns the translated string.</param>
|
/// <param name="neutral">The neutral (non-translated) string.</param>
|
/// <param name="key">Lookup key for finding the translation.</param>
|
/// <param name="language">The desired translation language</param>
|
/// <returns>The translated string, if a translation exists. Otherwise, returns the neutral string.</returns>
|
public static string Translate(this IStringLocalizer stringLocalizer, string neutral,
|
[CallerMemberName] string key = null, CultureInfo language = null)
|
{
|
return TranslateFunction(stringLocalizer, neutral, key, language);
|
}
|
|
// We add this small level of indirection in order to inject a hook to automatically
|
// populate a list of lookup keys and strings for creating translations.
|
// Do not rename this field or change the delegate!!
|
private static Func<IStringLocalizer, string, string, CultureInfo, string> TranslateFunction = _translate;
|
|
private static string _translate(this IStringLocalizer stringLocalizer, string neutral,
|
[CallerMemberName] string key = null, CultureInfo language = null)
|
{
|
language ??= EngineSettings.Current.Language;
|
if (language.Equals(NeutralLanguage) || string.IsNullOrWhiteSpace(key))
|
return neutral;
|
var type = stringLocalizer.GetType();
|
if (type.IsGenericType)
|
type = type.GetGenericTypeDefinition();
|
var fullKey = type.FullName + $".{key}";
|
return TranslateKey(fullKey, language) ?? neutral;
|
}
|
|
static int CountTemplates(string s)
|
{
|
var chars = s.ToArray();
|
int n = 0;
|
bool bracketOpen = false;
|
for (int i = 0; i < chars.Length; i++)
|
{
|
if (!bracketOpen && chars[i] == '{')
|
{
|
bracketOpen = true;
|
}
|
else if (bracketOpen && chars[i] == '{')
|
{
|
/* double bracket escapes */
|
bracketOpen = false;
|
}
|
else if (bracketOpen && chars[i] == '}')
|
{
|
bracketOpen = false;
|
n++;
|
}
|
}
|
|
return n;
|
}
|
|
private static readonly TraceSource log = Log.CreateSource("Translation Manager");
|
}
|
|
/// <summary>
|
/// An IStringLocalizer can define localizable strings by calling the Translate() or TranslateFormat() method from a public computed property.
|
/// Example: public string MyString => Translate("Neutral string") // returns "Translated string" if available
|
/// A localizable string defaults to the neutral string, unless, OpenTAP is configured to display in a different
|
/// language in which a translation is available.
|
/// </summary>
|
public interface IStringLocalizer : ITapPlugin
|
{
|
}
|
|
/// <summary>
|
/// A FormatString is a string which requires format parameters.
|
/// </summary>
|
public class FormatString(string format)
|
{
|
|
/// <summary>
|
/// Creates a formatted string based on this instance and the provided format arguments.
|
/// </summary>
|
/// <param name="args">The format arguments</param>
|
/// <returns>The formatted string</returns>
|
public string Format(params object[] args) => string.Format(format, args);
|
}
|
