private void UpdateLanguage(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.HealthCheckStatusHeaderText = this._languageService.GetString("HealthCheckStatusHeaderText");
this.HealthCheckStartExaminationButtonText = this._languageService.GetString("HealthCheckStartExaminationButtonText");
this.HealthCheckAutomaticRetryPluralText = this._languageService.GetString("HealthCheckAutomaticRetryPluralText");
this.HealthCheckAutomaticRetrySingularText = this._languageService.GetString("HealthCheckAutomaticRetrySingularText");
this.OverallStatusText = this._languageService.GetString(this.OverallStatusTextKey);
}));
}
public void ChangeLanguage(LuaTable language)
{
if (languageTable != null && languageTable != language)
{
languageTable.Dispose();
languageTable = null;
}
languageTable = language;
cachedTextDic.Clear();
OnLanguageChanged?.Invoke();
}
public static void SetLanguageId(int lang)
{
if (lang < LoadedLanguages && lang >= 0)
{
LanguageId = lang;
OnLanguageChanged?.Invoke();
}
else
{
Debug.LogWarning($"Language ID of {lang} is not a valid ID.");
}
}
private void LanguageChanged(Object sender, EventArgs e)
{
CultureInfo currentLanguage = App.Language;
foreach (MenuItem item in Menu.Items)
{
CultureInfo cultureInfo = item.Tag as CultureInfo;
item.IsChecked = cultureInfo != null && cultureInfo.Equals(currentLanguage);
}
OnLanguageChanged?.Invoke();
}
/// <summary>
/// Change current player language (for editor test only).
/// </summary>
/// <param name="indexLanguage"></param>
public static void ChangeLanguage(int indexLanguage)
{
if (localizedLanguages.Count == 0)
{
Debug.LogWarning("<color=yellow>SIMPLE-LOCALIZATOR ERROR</color>: localizator didn't find any language in translations file.");
return;
}
ChangeLanguage(localizedLanguages[indexLanguage].Language);
OnLanguageChanged?.Invoke();
}
public static void SetCurrentUserLanguage(string cultureCode)
{
int newLangIdx = CodeLanguageIdx;
if (cultureCode == "de" || cultureCode.StartsWith("de-"))
{
newLangIdx = Array.IndexOf(Languages, "de");
}
else if (cultureCode == "fr" || cultureCode.StartsWith("fr-"))
{
newLangIdx = Array.IndexOf(Languages, "fr");
}
else if (cultureCode == "ja" || cultureCode.StartsWith("ja-"))
{
newLangIdx = Array.IndexOf(Languages, "ja");
}
else if (cultureCode == "ko" || cultureCode.StartsWith("ko-"))
{
newLangIdx = Array.IndexOf(Languages, "ko");
}
else if (cultureCode == "zh" || cultureCode.StartsWith("zh-"))
{
newLangIdx = Array.IndexOf(Languages, "cn");
}
else
{
newLangIdx = CodeLanguageIdx;
}
bool changed = false;
if (newLangIdx != UserLanguageIdx)
{
UserLanguageIdx = newLangIdx;
changed = true;
}
var locManager = LocResourceManager.Get();
if (locManager.UserCultureCode != cultureCode)
{
CultureInfo.CurrentUICulture = new CultureInfo(cultureCode);
locManager.SetCurrentUserLanguage(CultureInfo.CurrentUICulture, typeof(loc.strings));
changed = true;
}
if (changed)
{
OnLanguageChanged?.Invoke();
Logger.WriteLine("Init localization: culture:{0} -> gameData:{1}, UI:{2}", cultureCode, Languages[UserLanguageIdx], locManager.UserCultureCode);
}
}
public void NextLanguage()
{
Index++;
if (Index >= AllLanguages.Length)
{
Index = 0;
}
CurrentLanguage = AllLanguages[Index];
if (OnLanguageChanged != null)
{
OnLanguageChanged.Invoke();
}
}
public static void SetUpLanguage()
{
if (Application.systemLanguage == SystemLanguage.Russian)
{
currentLanguage = GameEnums.Language.RU;
}
else
{
currentLanguage = GameEnums.Language.ENG;
}
OnLanguageChanged?.Invoke();
}
private void UpdateLanguage(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.HandInReceivedDoneText = this._languageService.GetString("HandInReceivedDoneText");
this.HandInReceivedEndProgramButtonText = this._languageService.GetString("HandInReceivedEndProgramButtonText");
this.HandInReceivedTypeHandinHeaderText = this._languageService.GetString("HandInReceivedTypeHandinHeaderText");
this.HandInReceivedTypeBlankHeaderText = this._languageService.GetString("HandInReceivedTypeBlankHeaderText");
this.HandInReceivedUploadedLateWarningText = this._languageService.GetString("HandInReceivedUploadedLateWarningText");
this.HandInReceivedSurveillanceText = this._languageService.GetString("HandInReceivedSurveillanceText");
this.HandInReceivedExaminationUrlText = this._languageService.GetString("HandInReceivedExaminationUrlText");
}));
}
private void UpdateText(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.LoginBoardingPassText = this._languageService.GetString("LoginBoardingPassText");
this.LoginBoardingPassHelperText = this._languageService.GetString("LoginBoardingPassHelperText");
this.LoginBoardingPassContinueButtonText = this._languageService.GetString("LoginBoardingPassContinueButtonText");
this.LoginFailedLoginText = this._languageService.GetString("LoginFailedLoginText");
this.LoginUnauthorizedBoardingPassText = this._languageService.GetString("LoginUnauthorizedBoardingPassText");
this.LoginFailedLoginButtonText = this._languageService.GetString("LoginFailedLoginButtonText");
this.OnPropertyChanged("BoardingPass");
}));
}
public void LoadLocalizedText(string langName)
{
string lang;
Debug.Log(CurrentLanguage + "Langguage System");
if (langName == "en_US")
{
lang = "en_US";
}
else
{
lang = "ru_RU";
}
string path = Application.streamingAssetsPath + "/Languages/" + lang + ".json";
string dataAsJson;
#if UNITY_ANDROID && !UNITY_EDITOR
WWW reader = new WWW(path);
UnityWebRequest unityWebRequest = new UnityWebRequest(path);
while (!reader.isDone)
{
}
if (langName == "en_US")
{
dataAsJson = reader.text;
}
else
{
dataAsJson = System.Text.Encoding.UTF8.GetString(reader.bytes, 3, reader.bytes.Length - 3);
}
#else
dataAsJson = File.ReadAllText(path);
#endif
LocalizationData loadedData = JsonUtility.FromJson <LocalizationData>(dataAsJson);
localizedText = new Dictionary <string, string>();
for (int i = 0; i < loadedData.items.Length; i++)
{
localizedText.Add(loadedData.items[i].key, loadedData.items[i].value);
}
CurrentLanguage = langName;
isReady = true;
LoadLocalizedSentence(langName);
OnLanguageChanged?.Invoke();
}
private void UpdateLanguage(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.HealthCheckText = this._languageService.GetString(this.HealthCheckTextKey);
if (!this.ShowReadMore)
{
return;
}
this.HealthCheckOnErrorReadMoreText = this._languageService.GetString("HealthCheckOnErrorReadMoreText");
this.HealthCheckOnErrorCloseReadMoreText = this._languageService.GetString("HealthCheckOnErrorCloseReadMoreText");
this.HealthCheckReadMoreText = this._languageService.GetString(this.HealthCheckReadMoreTextKey);
}));
}
private void UpdateLanguage(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.OngoingExamHeaderText = this._languageService.GetString("OngoingExamHeaderText");
this.AssignmentFilesPathViewModel.PathText = this._languageService.GetString("OngoingExamAssignmentFilesPathText");
this.HandInPathViewModel.PathText = this._languageService.GetString("OngoingExamHandInPathText");
this.OngoingExamExamTitleText = this._languageService.GetString("OngoingExamExamTitleText");
this.OngoingExamSubmitHandInButtonText = this._languageService.GetString("OngoingExamSubmitHandInButtonText");
this.OngoingExamSubmitBlankButtonText = this._languageService.GetString("OngoingExamSubmitBlankButtonText");
this.OngoingExamOnlyExternalHandinEnabledText = this._languageService.GetString("OngoingExamOnlyExternalHandinEnabledText");
this.OngoingExamNotYetAllowedToHandInText = this._languageService.GetString("OngoingExamNotYetAllowedToHandInText");
this.OnPropertyChanged("ExamTitle");
}));
}
private void UpdateLanguage(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.HandInSubmittingSubmissionRegisteredText = this._languageService.GetString("HandInSubmittingSubmissionRegisteredText");
this.HandInSubmittingWarningCloseText = this._languageService.GetString("HandInSubmittingWarningCloseText");
this.HandInSubmittingReceiptDetailsText = this._languageService.GetString("HandInSubmittingReceiptDetailsText");
this.HandInSubmittingTaggedLateText = this._languageService.GetString("HandInSubmittingTaggedLateText");
this.HandInSubmittingPendingQueueStatusText = this._languageService.GetString("HandInSubmittingPendingQueueStatusText");
this.HandInSubmittingDoneStatusText = this._languageService.GetString("HandInSubmittingDoneStatusText");
this.HandInSubmittingErrorStatusText = this._languageService.GetString("HandInSubmittingErrorStatusText");
this.HandInSubmittingUploadingStatusText = this._languageService.GetString("HandInSubmittingUploadingStatusText");
this.HandInSubmittingProgressStatusText = this.HandInSubmittingPendingQueueStatusText;
}));
}
/// <summary>
/// Load language from resource files
/// </summary>
/// <param name="path">the language file path</param>
void ResourceLoadLanguage(string path)
{
TextAsset texts = Resources.Load(path) as TextAsset;
if (texts == null)
{
Debug.LogError("UCL_LocalizeManager ResourceLoadLanguage path:" + path + ",not exist!!");
return;
}
string data = texts.ToString();
m_LocalizeData = new LocalizeData(data);
Debug.LogWarning("ResourceLoadLanguage:" + path);
OnLanguageChanged.Invoke();
}
/// <summary>
/// Change current player language (for test only - any mobile test button).
/// </summary>
public static void ChangeLanguage()
{
if (localizedLanguages.Count == 0)
{
Debug.LogWarning("<color=yellow>SIMPLE-LOCALIZATOR ERROR</color>: localizator didn't find any language in translations file.");
return;
}
int indexCurrentLanguage = localizedLanguages.IndexOf(cashLocalizedCurrentLanguage);
int indexNextLanguage = (indexCurrentLanguage + 1) % localizedLanguages.Count;
ChangeLanguage(localizedLanguages[indexNextLanguage].Language);
OnLanguageChanged?.Invoke();
}
private static void SetLanguage(Language language)
{
var tag = EnumCache <Language> .Description(language);
if (LanguageTag == tag)
{
return;
}
Language = language;
LanguageTag = tag;
Roots.ForEach(menu => menu.UpdateTranslations());
OnLanguageChanged.SafeInvoke(EventArgs.Empty);
}
public async Task SetLanguageAsync(string tag)
{
if (tag == CurrentLanguage)
{
return;
}
ApplicationLanguages.PrimaryLanguageOverride = tag;
ResourceContext.GetForCurrentView().Reset();
ResourceContext.GetForViewIndependentUse().Reset();
// Workaround, otherwise the first language change does not update the resources.
await Task.Delay(TimeSpan.FromMilliseconds(200));
OnLanguageChanged?.Invoke(this, tag);
}
/// <summary>
/// Sets an active language, all localization requests will from now on be querying the provided language
/// </summary>
/// <param name="languageCode">the language code to set as active</param>
/// <param name="setAsDefault">a flag to set the default language, should be used only once</param>
public void SetActiveLanguage(string languageCode, bool setAsDefault = false)
{
languageCode = languageCode.Trim().ToLower();
if (languageDictionary.ContainsKey(languageCode))
{
currentLanguage = languageDictionary[languageCode];
OnLanguageChanged?.Invoke(this, EventArgs.Empty);
if (setAsDefault)
{
defaultLanguage = currentLanguage;
}
}
else
{
throw new InvalidOperationException($"Language with code {languageCode} is not implemented!");
}
}
private void OnApplicationPause(bool pause)
{
if (!pause)
{
//MainCommon.LauncherApp.GetLanguage();
//Debug.Log(Application.systemLanguage+",Test");
Debug.Log("language:" + SystemCurrentLanguage.CurrentLanguage + "," + m_previousLanguage);
if (SystemCurrentLanguage.CurrentLanguage != m_previousLanguage)
{
setLanguage(mXMLParaser, SystemCurrentLanguage.CurrentLanguage);
if (OnLanguageChanged != null)
{
OnLanguageChanged.Invoke();
}
m_previousLanguage = SystemCurrentLanguage.CurrentLanguage;
}
}
}
public void ChangeCurrentLanguage(string lang)
{
var selected = Array.IndexOf(m_supportedLang, lang);
if (selected == -1)
{
throw new Exception($"Not supported language : {lang}");
}
if (m_currentLang == selected)
{
return;
}
m_currentLang = selected;
m_languageText.Clear();
RefreshLanguageText();
OnLanguageChanged?.Invoke();
}
private void Update()
{
#if UNITY_EDITOR
if (Input.GetKeyDown(KeyCode.UpArrow))
{
SystemCurrentLanguage.m_systemLanguage = SystemLanguage.English;
setLanguage(mXMLParaser, SystemLanguage.English);
if (OnLanguageChanged != null)
{
OnLanguageChanged.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.DownArrow))
{
SystemCurrentLanguage.m_systemLanguage = SystemLanguage.Chinese;
setLanguage(mXMLParaser, SystemLanguage.Chinese);
if (OnLanguageChanged != null)
{
OnLanguageChanged.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
SystemCurrentLanguage.m_systemLanguage = SystemLanguage.Japanese;
setLanguage(mXMLParaser, SystemLanguage.Japanese);
if (OnLanguageChanged != null)
{
OnLanguageChanged.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.RightArrow))
{
SystemCurrentLanguage.m_systemLanguage = SystemLanguage.Korean;
setLanguage(mXMLParaser, SystemLanguage.Korean);
if (OnLanguageChanged != null)
{
OnLanguageChanged.Invoke();
}
}
#endif
}
public static void ChangeCurrentLanguage(string newLanguage)
{
switch (newLanguage)
{
case "English":
currentLanguage = Languages.English;
break;
case "Russian":
currentLanguage = Languages.Russian;
break;
case "Belarusian":
currentLanguage = Languages.Belarusian;
break;
default:
throw new NotImplementedException($"{newLanguage} not implemented yet");
}
OnLanguageChanged?.Invoke();
}
/// Loads the categories
///
private void LoadCategories()
{
m_loader.Clear();
int loaded = 0;
var resources = GetResourcesForLanguage(m_language);
foreach (var resource in resources)
{
m_loader.LoadResource(resource.Key, resource.Value, () =>
{
++loaded;
if (loaded == resources.Count)
{
m_loaded = true;
PlayerPrefs.SetString(LocalisedTextIdentifiers.k_languageSettings, m_language.ToString());
PlayerPrefs.Save();
OnLanguageChanged.SafeInvoke();
}
});
}
}
private void UpdateLanguage(OnLanguageChanged onLanguageChanged = null)
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() =>
{
this.WorkspaceChooseWorkspaceText = this._languageService.GetString("WorkspaceChooseWorkspaceText");
this.WorkspaceSelectFolderButtonText = this._languageService.GetString("WorkspaceSelectFolderButtonText");
this.WorkspaceAssignmentFilesPathText = this._languageService.GetString("WorkspaceAssignmentFilesPathText");
this.WorkspaceHandInPathText = this._languageService.GetString("WorkspaceHandInPathText");
this.WorkspaceTimeUntilSingularText = this._languageService.GetString("WorkspaceTimeUntilSingularText");
this.WorkspaceTimeUntilPluralText = this._languageService.GetString("WorkspaceTimeUntilPluralText");
this.WorkspaceAssignmentFilesLockedText = this._languageService.GetString("WorkspaceAssignmentFilesLockedText");
this.WorkspaceAssignmentFilesDownloadedText = this._languageService.GetString("WorkspaceAssignmentFilesDownloadedText");
this.WorkspaceAssignmentFilesNoFilesText = this._languageService.GetString("WorkspaceAssignmentFilesNoFilesText");
this.WorkspaceAssignmentFilesDownloadingText = this._languageService.GetString("WorkspaceAssignmentFilesDownloadingText");
this.WorkspaceAssignmentFilesFailedDownloadingText = this._languageService.GetString("WorkspaceAssignmentFilesFailedDownloadingText");
this.WorkspaceHandInDirectoryText = this._languageService.GetString("WorkspaceHandInDirectoryText");
this.WorkspaceDirectoryAccessDeniedErrorButtonText = this._languageService.GetString("WorkspaceDirectoryAccessDeniedErrorButtonText");
this.WorkspaceDirectoryAccessDeniedErrorText = this._languageService.GetString("WorkspaceDirectoryAccessDeniedErrorText");
this.WorkspaceAssignmentFilesDirectoryText = this._languageService.GetString("WorkspaceAssignmentFilesDirectoryText");
this.UpdateWorkspace(this.WorkspaceBasePath);
this.OnPropertyChanged("WorkspaceShowAssignmentFilesUnlockButtonText");
}));
}
public void SetLanguage(LanguageType languageType)
{
LanguageType = languageType;
if (languageType == LanguageType.en_us)
{
StaticViewModel.GlobalViewModel.IsEnglish = true;
}
else
{
StaticViewModel.GlobalViewModel.IsEnglish = false;
}
//1.get resource uri
string path = string.Format("pack://application:,,,/OmniCoin.Wallet.Win;component/lang/{0}.xaml", languageType);
var resourceLoactor = new Uri(path);
//2.find the resource file in Application, if it exists, it must be deleted
var resources = Application.Current.Resources;
var languageResource = resources.MergedDictionaries.FirstOrDefault(x => x.Source == resourceLoactor);
if (languageResource != null)
{
resources.MergedDictionaries.Remove(languageResource);
}
//3.Readd the language file to the top
ResourceDictionary resource = new ResourceDictionary();
resource.Source = resourceLoactor;
Application.Current.Resources.MergedDictionaries.Add(resource);
_languageResource = resource;
ReLoadLanguageEntry();
LoadErrorCodes(languageType);
OnLanguageChanged?.Invoke(languageType);
}
public void Awake()
{
mInstance = this;
mXMLParaser = new XMLParser();
initLanguage(new XMLParser());
OnLanguageChanged.AddListener(() =>
{
for (int i = 0; i < listaction.Count; i++)
{
var item = listaction[i];
if (item.text == null)
{
listaction.Remove(item);
}
else
{
item.action.Invoke();
}
}
});
//m_previousLanguage = Application.systemLanguage;
m_previousLanguage = SystemCurrentLanguage.CurrentLanguage;
}
/// <summary>
/// Raises language change event.
/// </summary>
private void RaiseLanguageChanged()
{
OnLanguageChanged?.Invoke();
}
public static void SetLocalizationType(LocalizationType type)
{
string cfgPath = $"{FinalPatchConst.LOCALIZATION_DIR}/{type.ToString().ToLower()}{FinalPatchConst.LOCALIZATION_EXT}";
bool found = false;
try
{
using (FileStream fs = File.Open(cfgPath, FileMode.Open, FileAccess.Read))
{
XmlSerializer serializer = new XmlSerializer(typeof(LocalizationData));
LocalizationData data = serializer.Deserialize(fs) as LocalizationData;
if (s_localizationMap == null)
{
s_localizationMap = new Dictionary <string, string>();
}
s_localizationMap.Clear();
foreach (var item in data.items)
{
s_localizationMap.Add(item.Key, item.Value);
}
found = true;
CurrentType = type;
EditorPrefs.SetInt(FinalPatchConst.KEY_FINAL_PATCH_LOCALIZATION, (int)type);
OnLanguageChanged?.Invoke();
}
}
catch { }
if (!found)
{
// create localization file
LocalizationData data = new LocalizationData()
{
items = new List <LocalizationItem>()
{
new LocalizationItem()
{
Key = "localization_key",
Value = "localization_value",
}
}
};
string dir = Path.GetDirectoryName(cfgPath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
using (FileStream fs = new FileStream(cfgPath, FileMode.Create, FileAccess.Write))
{
XmlSerializer serializer = new XmlSerializer(typeof(LocalizationData));
serializer.Serialize(fs, data);
}
Debug.LogFormat("Create Localization File:{0}", cfgPath);
AssetDatabase.Refresh();
SetLocalizationType(type);
}
}
protected void ddlLanguage_SelectedIndexChanged(object sender, EventArgs e)
{
OnLanguageChanged?.Invoke(sender, e);
}
