/// <summary>
/// OnLanguageChange
/// </summary>
private static void OnLanguageChange()
{
if (LanguageChanged != null)
{
LanguageChanged.Invoke();
}
}
protected static void OnLanguageChanged()
{
if (LanguageChanged != null)
{
LanguageChanged.Invoke(null, new EventArgs());
}
}
public AutumnBoxGuiBaseApiImpl()
{
this.GetComponent <ILanguageManager>().LanguageChanged += (s, e) =>
{
LanguageChanged?.Invoke(this, new EventArgs());
};
}
public void SetLanguage(CultureInfo culture)
{
if (!culture.Equals(CultureInfo.CurrentCulture))
{
CultureInfo.CurrentCulture = culture;
}
if (CurrentCulture == null || !CurrentCulture.Equals(culture))
{
CurrentCulture = culture;
CultureInfo.DefaultThreadCurrentCulture = culture;
CultureInfo.DefaultThreadCurrentUICulture = culture;
string fileName = $"{_resourcesAssembly.GetName().Name}.Resources.{culture.Name}.json";
Resources = GetKeysFromCulture(culture.Name, fileName);
if (Resources == null)
{
throw new FileNotFoundException($"There is no language files for '{culture.Name}' existing in the Resources folder within '{_resourcesAssembly.GetName().Name}' assembly");
}
LanguageChanged?.Invoke(this, culture);
}
}
private void LoadLanguage(LanguageResources resources)
{
_translations = resources.Translations;
SelectedLanguage = new CultureInfo(resources.Language);
AvailableLanguages = resources.AvailableLanguages.Select(n => new CultureInfo(n)).ToList();
LanguageChanged?.Invoke(this, EventArgs.Empty);
}
public void RefreshLanguageSettings()
{
this.CommonResources = new CommonResources();
this.RaisePropertyChanged("CommonResources");
LanguageChanged?.Invoke(this, null);
}
private void btnLanguage_Click(object sender, EventArgs e)
{
currentLanguage = languagesList.SingleOrDefault(lang => lang.TwoLetterISOLanguageName != currentLanguage.TwoLetterISOLanguageName);
Thread.CurrentThread.CurrentCulture = currentLanguage;
Thread.CurrentThread.CurrentUICulture = currentLanguage;
LanguageChanged?.Invoke(this, new PropertyChangedEventArgs("Language changed")); //MLHIDE
}
public static void SwitchLanguageWithCallOut(FrameworkElement element, string inFiveCharLang)
{
/////// Get previously saved localization info
//var elType = element.GetType().ToString();
//var elNames = elType.Split('.');
//var appName = elNames[0];
//var elName = elNames[elNames.Length - 1];
Thread.CurrentThread.CurrentUICulture = new CultureInfo(inFiveCharLang);
SetLanguageResourceDictionary(element, GetLocXAMLFilePath(getElementName(element), inFiveCharLang));
// Save new culture info to registry-
RegistryKey UserPrefs = Registry.CurrentUser.OpenSubKey("GsmLib" + @"\" + getAppName(element), true);
if (UserPrefs == null)
{
// Value does not already exist so create it
RegistryKey newKey = Registry.CurrentUser.CreateSubKey("GsmLib");
UserPrefs = newKey.CreateSubKey(getAppName(element));
}
UserPrefs.SetValue(getElementName(element) + ".localization", inFiveCharLang);
LanguageChanged?.Invoke(new object(),
new LanguageChangedEventArgs(inFiveCharLang));
App.Language = new CultureInfo(inFiveCharLang);
}
public void SwitchLanguage(Language newLanguage)
{
if (newLanguage != null && newLanguage != CurrentLanguage)
{
CurrentLanguage = newLanguage;
LanguageChanged?.Invoke(this, EventArgs.Empty);
}
}
public void SetLanguage(CultureInfo culture)
{
if (CurrentCulture == null || !CurrentCulture.Equals(culture))
{
CurrentCulture = culture;
LanguageChanged?.Invoke(this, culture);
}
}
private void SetLanguage(CultureInfo culture, bool isDefault)
{
if (CurrentCulture == null || !CurrentCulture.Equals(culture))
{
CurrentCulture = culture;
LanguageChanged?.Invoke(this, culture);
}
}
/// <summary>
/// Load current localization
/// Part of ISerializationCallbackReceiver
/// </summary>
public void Load()
{
try
{
#if UNITY_WEBGL || UNITY_ANDROID
var ms = Camera.main.GetComponent <MainScript>();
var networking = ms.m_networking;
string loc = SCurrentLocalization.m_languages.m_languages[SCurrentLocalization.m_currentLanguage];
networking.GetLocalization(loc, 1, delegate(string answerUi)
{
m_ui = JsonUtility.FromJson <UiLocalization>(NetworkManager.ByteToJson(answerUi));
});
networking.GetLocalization(loc, 2, delegate(string answerItm)
{
m_items = new ItemsLocalization();
m_items = JsonUtility.FromJson <ItemsLocalization>(NetworkManager.ByteToJson(answerItm));
if (m_items?.m_itemList != null)
{
FillItemDictionary();
}
});
networking.GetLocalization(loc, 3, delegate(string answerHis)
{
m_history = JsonUtility.FromJson <HistoryLocalization>(NetworkManager.ByteToJson(answerHis));
m_onLanguageChanged?.Invoke();
});
#else
Console.WriteLine("UnityWebGL does not works");
var hisAss = Resources.Load <TextAsset>(m_sHistoryFullPath);
m_history = JsonUtility.FromJson <HistoryLocalization>(hisAss.text);
var itmAss = Resources.Load <TextAsset>(m_sItemsFullPath);
m_items = JsonUtility.FromJson <ItemsLocalization>(itmAss.text);
FillItemDictionary();
var uiAss = Resources.Load <TextAsset>(m_sUiFullPath);
m_ui = JsonUtility.FromJson <UiLocalization>(uiAss.text);
#endif
}
catch (Exception ex)
{
Debug.Log(ex);
}
}
public static void SetLanguage(string code)
{
if (code == "" || !languages.ContainsKey(code))
{
code = GetBestLanguageCode();
}
ReadLanguageFile(strings, languages[code]);
activeLangCode = code;
LanguageChanged?.Invoke(null, new EventArgs());
}
private void Apply(ILanguage lang)
{
if (Current.Equals(lang))
{
return;
}
App.Current.Resources.MergedDictionaries[INDEX_OF_LANG] = lang.Resource;
Settings.Default.Language = lang.LanCode;
Settings.Default.Save();
LanguageChanged?.Invoke(this, new EventArgs());
}
private static void LoadAllLanguages(string folderPath)
{
LoadEmbeddedLanguages();
if (Directory.Exists(folderPath))
{
LoadXMLLanguages(folderPath);
LoadTXTLanguages(folderPath);
}
CurrentLanguage = AllLanguages["pol"];
LanguageChanged?.Invoke(null, EventArgs.Empty);
}
public static void ChangeLanguage(string languageID)
{
if (AllLanguages.ContainsKey(languageID))
{
CurrentLanguage = AllLanguages[languageID];
LanguageChanged?.Invoke(null, EventArgs.Empty);
SettingsManager.Settings = new SettingsSet(false)
{
LanguageID = languageID
};
}
}
public bool TryToSetLanguage(string newLanguage)
{
if (!languageDictionaries.TryGetValue(newLanguage, out currentLanguageDictionary))
{
Debug.LogError($"There is no dictionary for this language: {newLanguage}");
return(false);
}
currentLanguage = newLanguage;
LanguageChanged?.Invoke();
return(true);
}
private void ChangeLanguage(object sender, RoutedEventArgs e)
{
foreach (var element in stack.Children)
{
var button = element as RadioButton;
if (button.IsChecked.Value)
{
CurrentLanguage = (string)button.Content;
LanguageChanged?.Invoke(this, (string)button.Content);
}
}
}
public void SelectLanguage(I18N.Lang lang)
{
if (_config.language != lang.name)
{
_config.language = lang.name;
SaveConfig(_config);
if (LanguageChanged != null)
{
LanguageChanged.Invoke(this, new EventArgs());
}
}
}
public void SwitchLanguage(string newLanguageName)
{
if (newLanguageName != null && newLanguageName != CurrentLanguage.Name)
{
Language newLanguage = Languages.FirstOrDefault(language => language.Name == newLanguageName);
if (newLanguage != null)
{
CurrentLanguage = newLanguage;
LanguageChanged?.Invoke(this, EventArgs.Empty);
}
}
}
public virtual void SetLanguage(CultureInfo culture)
{
_currentCulture = culture;
InitResources();
if (_additionalLocalizers.Count > 0)
{
foreach (var localizer in _additionalLocalizers.Values)
{
localizer.SetLanguage(culture);
}
}
LanguageChanged?.Invoke(this, _currentCulture);
}
public void ApplyXmlStringsResource(string resourceName)
{
if (!(Application.Current.TryFindResource("Strings") is XmlDataProvider provider))
{
return;
}
provider.Source = new Uri(resourceName, UriKind.RelativeOrAbsolute);
provider.Refresh();
LanguageChanged?.Invoke(this, new EventArgs());
}
private void SwitchLanguage(Language language)
{
if (language == null)
{
return;
}
Thread.CurrentThread.CurrentCulture = language.CultureInfo;
Thread.CurrentThread.CurrentUICulture = language.CultureInfo;
SetLanguageResourceDictionary(language);
CurrentLanguage = language;
LanguageChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Changes the current language of the application
/// </summary>
/// <param name="languageCode">The new language</param>
public bool ChangeLanguage(string languageCode)
{
Language oldLang = LanguageManager.GetCurrentLanguage();
Language newLang;
// Try get language
try { newLang = LanguageManager.GetLanguage(languageCode); } catch { return(false); }
LanguageManager.SetLanguage(newLang); // Set the language
// Fire language changed
LanguageChanged?.Invoke(this, new LanguageChangedEventArgs(oldLang, newLang));
return(true);
}
public static void SetLanguage(string languageCode)
{
try
{
var lang = Langs.Find((language) => language.LanguageCode == languageCode);
App.Current.Resources.MergedDictionaries[0] = lang.Resources;
SaveLangSetting();
LanguageChanged?.Invoke(new object(), new EventArgs());
}
catch (Exception)
{
SetLanguage("zh-CN");
}
}
/// <summary>
/// The callback of the Realized Event.
/// </summary>
/// <since_tizen> preview </since_tizen>
protected override void OnRealized()
{
base.OnRealized();
_languageChanged = new SmartEvent(this, this.RealHandle, "language,changed");
_languageChanged.On += (s, e) =>
{
LanguageChanged?.Invoke(this, EventArgs.Empty);
};
_themeChanged = new SmartEvent(this, this.RealHandle, "theme,changed");
_themeChanged.On += (s, e) =>
{
ThemeChanged?.Invoke(this, EventArgs.Empty);
};
}
void RefreshNodes_UI()
{
uiDispatcher.VerifyAccess();
var info = TryGetLanguage();
if (info.language != language)
{
language = info.language;
LanguageChanged?.Invoke(this, EventArgs.Empty);
}
bool newIsReadOnly = info.frame == null;
NodesChanged?.Invoke(this, EventArgs.Empty);
SetIsReadOnly_UI(newIsReadOnly);
}
public void ChangeLanguage(string lngKey, bool force = false)
{
Language newLng = GetLanguage(lngKey);
if (newLng != null)
{
CurrentLanguage = newLng;
}
else
{
SetDefaultLanguage();
}
Logging.Instance.Info(TAG, nameof(ChangeLanguage), $"language changed to {CurrentLanguage.Key} {CurrentLanguage.DisplayName}");
LanguageChanged?.Invoke();
}
internal static void UpdateErrorDictionary()
{
try
{
instance.Clear();
foreach (var error in Enum.GetValues(typeof(ErrorMessageType)).Cast <ErrorMessageType>())
{
if (error != ErrorMessageType.None)
{
instance.Add(error, TranslationSource.Instance[$"Error_{error.ToString()}"]);
}
}
LanguageChanged?.Invoke();
}
catch { }
}
public static void UpdateLanguage(string languageCode)
{
var existingLanguage = TranslationSource.Instance.CurrentCulture ?? CultureInfo.CurrentCulture;
var culture = GetSupportedCultureInfo(languageCode);
if (!Equals(culture, existingLanguage))
{
TranslationSource.Instance.CurrentCulture = culture;
CultureInfo.DefaultThreadCurrentCulture = culture;
CultureInfo.DefaultThreadCurrentUICulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
Thread.CurrentThread.CurrentCulture = culture;
LanguageChanged?.Invoke(typeof(Internationalization), culture);
}
}