/// <summary> Deletes the language. </summary> public static void DeleteLanguage(SmartCultureInfo cultureInfo) { string filePath = LocalizationWorkspace.LanguageFilePath(cultureInfo.languageCode); if(FileUtility.Exists(filePath)) { FileUtility.Delete(filePath); FileUtility.Delete(filePath + LocalizationWorkspace.metaFileEnding); } //The text file filePath = LocalizationWorkspace.ResourcesFolderFilePath() + "/" + LocalizationWorkspace.rootLanguageName + "." + cultureInfo.languageCode + LocalizationWorkspace.txtFileEnding; if(FileUtility.Exists(filePath)) { FileUtility.Delete(filePath); FileUtility.Delete(filePath + LocalizationWorkspace.metaFileEnding); } //The assets directory filePath = LocalizationWorkspace.LanguageRuntimeFolderPath(cultureInfo.languageCode); if(Directory.Exists(filePath)) { Directory.Delete(filePath + "/", true); FileUtility.Delete(filePath + LocalizationWorkspace.metaFileEnding); } SmartCultureInfoCollection allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); LanguageHandlerEditor.CheckAndSaveAvailableLanguages(allCultures); AssetDatabase.Refresh(); }
public static void UpdateLanguageFile(string languageCode, List<List<string>> values) { Dictionary<string,string> languageItems = null; if(FileUtility.Exists(LocalizationWorkspace.LanguageFilePath(languageCode))) { languageItems = LanguageHandlerEditor.LoadLanguageFile(languageCode, false); } else { languageItems = new Dictionary<string, string>(); } int updatedKeys = 0; foreach (List<string> row in values) { if (row.Count != 2) { continue; } string key = row[0].TrimStart('\r', '\n').TrimEnd('\r', '\n').Trim(); string value = row[1]; if (!languageItems.ContainsKey(key)) { continue; } languageItems[key] = value; updatedKeys++; } LanguageHandlerEditor.SaveLanguageFile(languageItems, LocalizationWorkspace.LanguageFilePath(languageCode)); Debug.Log("Updated language:" + languageCode + ", Keys updated:" + updatedKeys); }
/// <summary> /// Creates a new language /// </summary> /// <param name="languageName">The language code of the language to create</param> /// <param name="fromFile">Base language values to create a language from where each list of strings is a row.</param> public static void CreateNewLanguage(string languageName, List<List<string>> fromFile = null) { Dictionary<string,string> rootValues = LanguageHandlerEditor.LoadLanguageFile(null, true); //Copy the keys over to the new language Dictionary<string,string> baseDictionary = new Dictionary<string, string>(); foreach(KeyValuePair<string, string> keyPair in rootValues) { baseDictionary.Add(keyPair.Key, ""); } if (fromFile != null) { foreach (var row in fromFile) { if (row.Count != 2) { Debug.LogError("The CSV file is not in the correct format."); break; } baseDictionary[row[0]] = row[1]; } } //Save the new language file SaveLanguageFile(baseDictionary, LocalizationWorkspace.LanguageFilePath(languageName)); }
void UpdateFromCSV(string chosenUpdateFile) { LanguageHandlerEditor.UpdateLanguageFile(chosenCulture.languageCode, CSVParser.Read(chosenUpdateFile, CSVParser.GetDelimiter(delimiter))); if (parentWindow.translateLanguageWindow != null) { parentWindow.translateLanguageWindow.ReloadLanguage(); } }
void UpdateFromXLS(string chosenUpdateFile) { var values = XLSExporter.Read(chosenUpdateFile); LanguageHandlerEditor.UpdateLanguageFile(chosenCulture.languageCode, values); if (parentWindow.translateLanguageWindow != null) { parentWindow.translateLanguageWindow.ReloadLanguage(); } }
/// <summary> /// Loads all the language files with their raw values /// </summary> /// <returns>A dictionary with all the language dictionaries. The language codes are being used as keys</returns> public static Dictionary<string,Dictionary<string,string>> LoadAllLanguageFiles() { var allLanguages = new Dictionary<string,Dictionary<string,string>>(); var availableCultures = LanguageHandlerEditor.CheckAndSaveAvailableLanguages(SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath())); foreach(SmartCultureInfo info in availableCultures.cultureInfos) { allLanguages.Add(info.languageCode, LoadLanguageFile(info.languageCode, false)); } return allLanguages; }
void OnCreateLanguageClick(SmartCultureInfo info) { SmartCultureInfo chosenCulture = allCultures.FindCulture(info); if (chosenCulture == null) { Debug.LogError("The language: " + info.englishName + " could not be created"); return; } LanguageHandlerEditor.CreateNewLanguage(chosenCulture.languageCode); InitializeCultureCollections(); }
void OnWatchedFileChanged(object source, FileSystemEventArgs e) { EditorThreadQueuer.QueueOnMainThread(() => { Console.WriteLine("File changed. Reloading..."); List <List <string> > values = CSVParser.Read(e.FullPath, CSVParser.GetDelimiter(CSVParser.Delimiter.COMMA)); LanguageHandlerEditor.UpdateLanguageFile(currentCultureInfo.languageCode, values); ReloadLanguage(); if (Application.isPlaying && LanguageManager.HasInstance) { LanguageManager.Instance.ChangeLanguage(currentCultureInfo.languageCode); } Repaint(); }); }
/// <summary> /// Draws the GUI for when the automatic translator is initialized and available for translation /// </summary> void DrawAvailableAutoTranslationGUI(float fullWindowWidth, Rect newPosition) { newPosition.width = fullWindowWidth * 0.69f; translateFromLanguageValue = EditorGUI.Popup(newPosition, "Translate From", translateFromLanguageValue, availableTranslateLangEnglishNames); newPosition.x += fullWindowWidth * 0.7f; if (oldTranslateFromLanguageValue != translateFromLanguageValue) { oldTranslateFromLanguageValue = translateFromLanguageValue; //The value have been changed, load the language file of the other language that you want to translate from //I load it like this to show the translate buttons only on the ones that can be translated i.e some values //in the "from" language could be an empty string - no use in translating that if (translateFromDictionary != null) { translateFromDictionary.Clear(); translateFromDictionary = null; } if (translateFromLanguageValue != 0) { string englishName = availableTranslateLangEnglishNames[translateFromLanguageValue]; foreach (SmartCultureInfo info in availableTranslateFromLanguages) { if (info.englishName == englishName) { translateFromDictionary = LanguageHandlerEditor.LoadParsedLanguageFile(info.languageCode, false); translateFromLanguage = info.languageCode; break; } } } } newPosition.width = fullWindowWidth * 0.14f; if (translateFromLanguageValue != 0) { if (GUI.Button(newPosition, "Translate all text")) { if (translateFromLanguageValue != 0) { TranslateAllText(); } } newPosition.x += fullWindowWidth * 0.15f; } if (GUI.Button(newPosition, "Refresh")) { CheckIfCanBeTranslated(); } }
void ExportToCSV(string chosenExportFolder) { string name = chosenCulture.englishName + " - " + chosenCulture.languageCode + ".csv"; var input = new List <List <string> >(); Dictionary <string, LocalizedObject> languageItems = LanguageHandlerEditor.LoadParsedLanguageFile(chosenCulture.languageCode, false); foreach (var item in languageItems) { var row = new List <string>(); row.Add(item.Key); row.Add(item.Value.TextValue); input.Add(row); } CSVParser.Write(chosenExportFolder + "/" + name, CSVParser.GetDelimiter(delimiter), input); }
void OnGotAvailableLanguages(bool success, List <string> availableLanguages) { if (!success) { return; } availableTranslateFromLanguages.Clear(); //Clear the array if (availableTranslateLangEnglishNames != null) { Array.Clear(availableTranslateLangEnglishNames, 0, availableTranslateLangEnglishNames.Length); availableTranslateLangEnglishNames = null; } if (translateFromDictionary != null) { translateFromDictionary.Clear(); translateFromDictionary = null; } translateFromLanguageValue = 0; oldTranslateFromLanguageValue = 0; List <string> englishNames = new List <string>(); englishNames.Add("None"); if (availableLanguages.Contains(currentCultureInfo.languageCode)) { canLanguageBeTranslated = true; SmartCultureInfoCollection allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); SmartCultureInfoCollection availableCultures = LanguageHandlerEditor.CheckAndSaveAvailableLanguages(allCultures); foreach (SmartCultureInfo cultureInfo in availableCultures.cultureInfos) { if (cultureInfo.languageCode != currentCultureInfo.languageCode && availableLanguages.Contains(cultureInfo.languageCode)) { availableTranslateFromLanguages.Add(cultureInfo); englishNames.Add(cultureInfo.englishName); } } } else { canLanguageBeTranslated = false; } availableTranslateLangEnglishNames = englishNames.ToArray(); }
/// <summary> /// Initializes the Language /// </summary> public void InitializeLanguage(SmartCultureInfo info, Dictionary <string, LocalizedObject> rootValues, Dictionary <string, LocalizedObject> languageValues) { this.rootValues = rootValues; this.loadedLanguageValues.Clear(); this.loadedLanguageValues = LanguageHandlerEditor.CreateSerializableLocalizationList(languageValues); //Load assets LanguageHandlerEditor.LoadAllAssets(this.loadedLanguageValues); this.thisLanguage = (currentCultureInfo.englishName + " - " + currentCultureInfo.languageCode); rootFileChanged = false; SortLanguageValues(sortType); localizedObjectAdaptor = new LocalizedObjectListAdaptor(this.loadedLanguageValues, null, DrawLanguageValue, 17, true); localizedObjectContextMenu = new LocalizedObjectMenuControl(); localizedObjectAdaptor.collapseMultiline = collapseMultilineFields; }
void ImportFromXLS(string chosenImportFile) { List <List <string> > values = XLSExporter.Read(chosenImportFile); if (chosenCulture == null) { Debug.LogError("The language: " + chosenCulture.englishName + " could not be created"); this.Close(); return; } LanguageHandlerEditor.CreateNewLanguage(chosenCulture.languageCode, values); if (creationDelegate != null) { creationDelegate(); creationDelegate = null; } }
void SaveRootLanguageFile() { var changeNewRootKeys = new Dictionary <string, string>(); var changeNewRootValues = new Dictionary <string, string>(); for (int i = 0; i < changedRootKeys.Count; i++) { SerializableStringPair rootKey = changedRootKeys[i]; SerializableLocalizationObjectPair rootValue = changedRootValues[i]; //Check for possible duplicates and rename them string newKeyValue = LanguageDictionaryHelper.AddNewKeyPersistent(changeNewRootKeys, rootKey.originalValue, rootValue.changedValue.GetFullKey(rootKey.changedValue)); //Check for possible duplicates and rename them(same as above) LanguageDictionaryHelper.AddNewKeyPersistent(changeNewRootValues, newKeyValue, rootValue.changedValue.TextValue); } //Add the full values before saving var changeNewRootKeysToSave = new Dictionary <string, string>(); var changeNewRootValuesToSave = new Dictionary <string, string>(); foreach (var rootKey in changeNewRootKeys) { LocalizedObject thisLocalizedObject = parsedRootValues[rootKey.Key]; changeNewRootKeysToSave.Add(thisLocalizedObject.GetFullKey(rootKey.Key), rootKey.Value); changeNewRootValuesToSave.Add(thisLocalizedObject.GetFullKey(rootKey.Key), changeNewRootValues[rootKey.Key]); } SmartCultureInfoCollection allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); LanguageHandlerEditor.SaveRootLanguageFile(changeNewRootKeysToSave, changeNewRootValuesToSave, LanguageHandlerEditor.CheckAndSaveAvailableLanguages(allCultures)); //Fire the root language changed event if (OnRootFileChanged != null) { OnRootFileChanged(); } //Reload the window(in case of duplicate keys) SetRootValues(LanguageHandlerEditor.LoadParsedLanguageFile(null, true)); }
/// <summary> /// Creates a new workspace. Returns false if a workspace already exists /// </summary> /// <returns>If the creation was a success.</returns> public static bool Create() { if (Exists()) { return(false); } if (DirectoryUtility.Create(WorkspaceFolderPath())) { if (!DirectoryUtility.Create(AutoGeneratedFolderPath())) { return(false); } if (!DirectoryUtility.Create(ResourcesFolderFilePath())) { return(false); } if (!DirectoryUtility.Create(DataFolderPath())) { return(false); } if (!DirectoryUtility.Create(LanguageDataFolderPath())) { return(false); } if (!GenerateCultureInfoCollection()) { return(false); } LanguageHandlerEditor.CreateRootResourceFile(); AssetDatabase.Refresh(); return(true); } return(false); }
void ShowImportGUI() { if (GUILayout.Button("Import")) { if (availableFileFormats[chosenFileFormat] == csvFileEnding) { string file = EditorUtility.OpenFilePanel("Select CSV file.", "", ""); if (file != null && file != "") { var values = CSVParser.Read(file, CSVParser.GetDelimiter(delimiter)); if (values.Count > 0) { LanguageHandlerEditor.BulkUpdateLanguageFiles(values); } } this.Close(); } else if (availableFileFormats[chosenFileFormat] == xlsFileEnding) { string file = EditorUtility.OpenFilePanel("Select XLS file.", "", ""); if (file != null && file != "") { var values = XLSExporter.Read(file); if (values.Count > 0) { LanguageHandlerEditor.BulkUpdateLanguageFiles(values); } } this.Close(); } else { Debug.LogError("BulkUpdateWindow: Unsupported import format!"); } if (parentWindow.translateLanguageWindow != null) { parentWindow.translateLanguageWindow.ReloadLanguage(); } } }
/// <summary> /// Checks .resx files and converts them into text assets that can be used at runtime /// </summary> public static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { //Only use this if there's a localization system created if (!LocalizationWorkspace.Exists()) { return; } foreach (string asset in importedAssets) { if (asset.EndsWith(LocalizationWorkspace.resXFileEnding)) { string newFileName = LocalizationWorkspace.ResourcesFolderFilePath() + "/" + Path.GetFileNameWithoutExtension(asset) + LocalizationWorkspace.txtFileEnding; if (!DirectoryUtility.CheckAndCreate(LocalizationWorkspace.ResourcesFolderFilePath())) { return; } //Delete the file if it already exists if (FileUtility.Exists(newFileName)) { FileUtility.Delete(newFileName); } string fileData = ""; using (StreamReader reader = new StreamReader(asset)) { fileData = reader.ReadToEnd(); } FileUtility.WriteToFile(newFileName, fileData); SmartCultureInfoCollection allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); LanguageHandlerEditor.CheckAndSaveAvailableLanguages(allCultures); AssetDatabase.Refresh(ImportAssetOptions.Default); } } }
private void SaveAndRebuild() { //Copy everything into a dictionary Dictionary <string, string> newLanguageValues = new Dictionary <string, string>(); foreach (var objectPair in loadedLanguageValues) { if (objectPair.changedValue.ObjectType == LocalizedObjectType.STRING) { newLanguageValues.Add(objectPair.changedValue.GetFullKey(objectPair.keyValue), objectPair.changedValue.TextValue); } else { //Delete the file in case there was a file there previously LanguageHandlerEditor.DeleteFileFromResources(objectPair.changedValue.GetFullKey(objectPair.keyValue), currentCultureInfo); //Store the path to the file string pathValue = string.Empty; if (objectPair.changedValue.OverrideLocalizedObject) { pathValue = "override=" + objectPair.changedValue.OverrideObjectLanguageCode; } else { pathValue = LanguageHandlerEditor.CopyFileIntoResources(objectPair, currentCultureInfo); } newLanguageValues.Add(objectPair.changedValue.GetFullKey(objectPair.keyValue), pathValue); } } LanguageHandlerEditor.SaveLanguageFile(newLanguageValues, LocalizationWorkspace.LanguageFilePath(currentCultureInfo.languageCode)); guiChanged = false; GUIUtility.keyboardControl = 0; if (Application.isPlaying && LanguageManager.HasInstance) { LanguageManager.Instance.ChangeLanguage(currentCultureInfo.languageCode); } }
protected override void OnItemRemoving(ItemRemovingEventArgs args) { SmartCultureInfoListAdaptor smartAdaptor = args.adaptor as SmartCultureInfoListAdaptor; if (smartAdaptor == null) { return; } SmartCultureInfo info = smartAdaptor.GetCultureInfo(args.itemIndex); if (EditorUtility.DisplayDialog("Delete " + info.englishName + "?", "Are you sure you want to delete " + info.englishName + " and all of its content from the project? You cannot undo this action.", "Yes, delete it.", "Cancel")) { LanguageHandlerEditor.DeleteLanguage(info); base.OnItemRemoving(args); } else { args.Cancel = true; } }
/// <summary> /// Refreshes the list containing the selectable keys /// </summary> /// <param name="sort">If the refreshed list should be sorted and filtered with a certain key type</param> /// <param name="sortType">The key type to use as filter</param> public static void RefreshList(bool sort, LocalizedObjectType sortType) { if (!Application.isPlaying) { parsedRootValues.Clear(); Dictionary <string, LocalizedObject> values = LanguageHandlerEditor.LoadParsedLanguageFile(null, true); if (sort) { loadedObjectType = sortType; foreach (KeyValuePair <string, LocalizedObject> pair in values) { if (pair.Value.ObjectType == sortType) { parsedRootValues.Add(pair.Key); } } } else { //Use invalid for showing all loadedObjectType = LocalizedObjectType.INVALID; parsedRootValues.AddRange(values.Keys); } if (parsedRootValues.Count > 0) { parsedRootValues.Insert(0, "--- No key selected ---"); } else { parsedRootValues.Add("--- No localized keys available ---"); } } }
void ShowExportGUI() { if (GUILayout.Button("Export")) { string folderPath = EditorUtility.OpenFolderPanel("Select folder to save to.", "", ""); if (availableFileFormats[chosenFileFormat] == csvFileEnding) { string fullPath = folderPath + "/" + exportFileName + csvFileEnding; CSVParser.Write(fullPath, CSVParser.GetDelimiter(delimiter), new List <string>(LanguageHandlerEditor.LoadLanguageFile(null, true).Keys), LanguageHandlerEditor.LoadAllLanguageFiles()); Debug.Log("Exported CSV file to " + fullPath); this.Close(); } else if (availableFileFormats[chosenFileFormat] == xlsFileEnding) { string fullPath = folderPath + "/" + exportFileName + xlsFileEnding; XLSExporter.Write(fullPath, "Languages", new List <string>(LanguageHandlerEditor.LoadLanguageFile(null, true).Keys), LanguageHandlerEditor.LoadAllLanguageFiles()); Debug.Log("Exported XLS file to " + fullPath); this.Close(); } else { Debug.LogError("BulkUpdateWindow: Unsupported export format!"); } } }
public void ReloadLanguage() { InitializeLanguage(currentCultureInfo, LanguageHandlerEditor.LoadParsedLanguageFile(null, true), LanguageHandlerEditor.LoadParsedLanguageFile(currentCultureInfo.languageCode, false)); }
void OnDeleteLanguageClick(SmartCultureInfo cultureInfo) { LanguageHandlerEditor.DeleteLanguage(cultureInfo); }
void OnRootEditClick() { ShowRootEditWindow(LanguageHandlerEditor.LoadParsedLanguageFile(null, true)); }
public void Initialize(SmartCultureInfo thisCultureInfo, bool forceNewLanguage = false) { if (thisCultureInfo != null) { if (undoManager == null) { // Instantiate Undo Manager undoManager = new HOEditorUndoManager(this, "Smart Localization - Translate Language Window"); } if (thisCultureInfo != null) { bool newLanguage = thisCultureInfo != this.currentCultureInfo ? true : false; if (Application.isPlaying || forceNewLanguage) { newLanguage = true; } this.currentCultureInfo = thisCultureInfo; if (loadedLanguageValues == null || loadedLanguageValues.Count < 1 || newLanguage) { InitializeLanguage(thisCultureInfo, LanguageHandlerEditor.LoadParsedLanguageFile(null, true), LanguageHandlerEditor.LoadParsedLanguageFile(thisCultureInfo.languageCode, false)); } } settingsList.Clear(); settingsList.Add("SETTINGS"); settingsList.Add("CONVERTLINEBREAK"); settingsList.Add("WATCHFILE"); settingsList.Add("AUTOTRANSLATE"); settingsList.Add("GENERAL"); #if UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3 if (EditorUserBuildSettings.activeBuildTarget != BuildTarget.WebPlayer && EditorUserBuildSettings.activeBuildTarget != BuildTarget.WebPlayerStreamed) #endif { settingsList.Add("SORT"); } settingsList.Add("SEARCH"); settingsAdaptor = new SettingsListAdaptor(settingsList, DrawSettingsItem, 20); settingsContextMenu = new SettingsMenuControl(); listColumns = new EditorColumns(0.02f, true); listColumns.AddColumn("Copy", 0.1f); listColumns.AddColumn("Translate", 0.1f); listColumns.AddColumn("Key", 0.21f); listColumns.AddColumn("Comment", 0.21f); listColumns.AddColumn("Override", 0.07f); listColumns.AddColumn("Value", 0.25f); listColumns.RecalculateColumnWidths(); if (EditorPrefs.HasKey(CollapseMultilineSaveKey)) { collapseMultilineFields = EditorPrefs.GetBool(CollapseMultilineSaveKey); } GUIUtility.keyboardControl = 0; SmartCultureInfoCollection allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); SmartCultureInfoCollection availableCultures = LanguageHandlerEditor.CheckAndSaveAvailableLanguages(allCultures); otherAvailableLanguageCodes.Clear(); otherAvailableLanguageCodesArray = null; foreach (SmartCultureInfo otherCulture in availableCultures.cultureInfos) { if (otherCulture.languageCode != thisCultureInfo.languageCode) { otherAvailableLanguageCodes.Add(otherCulture.languageCode); } } if (otherAvailableLanguageCodes.Count > 0) { otherAvailableLanguageCodesArray = otherAvailableLanguageCodes.ToArray(); } } }
void OnGUI() { if (LocalizationWindowUtility.ShouldShowWindow()) { GUILayout.Label("Create a new culture info", EditorStyles.boldLabel); languageCode = EditorGUILayout.TextField("Language Code", languageCode); if (languageCode != null) { languageCode = languageCode.RemoveWhitespace(); } englishName = EditorGUILayout.TextField("English Name", englishName); nativeName = EditorGUILayout.TextField("Native Name", nativeName); isRightToLeft = EditorGUILayout.Toggle("Is Right To Left", isRightToLeft); if (GUILayout.Button("Create")) { SmartCultureInfo newInfo = new SmartCultureInfo(); newInfo.languageCode = languageCode; newInfo.englishName = englishName.Trim(); newInfo.nativeName = nativeName.Trim(); newInfo.isRightToLeft = isRightToLeft; SmartCultureInfoCollection allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); if (!allCultures.IsCultureInCollection(newInfo)) { allCultures.AddCultureInfo(newInfo); allCultures.Serialize(LocalizationWorkspace.CultureInfoCollectionFilePath()); LanguageHandlerEditor.CheckAndSaveAvailableLanguages(allCultures); showHelpMessage = true; helpMessageType = MessageType.Info; helpMessage = string.Format("Successfully created language!\n Language Code: {0}\n English Name:{1}\n Native Name:{2}\n IsRightToLeft:{3}", newInfo.languageCode, newInfo.englishName, newInfo.nativeName, newInfo.isRightToLeft); if (parentWindow != null) { parentWindow.InitializeCultureCollections(true); } this.Close(); } else { SmartCultureInfo conflictingCulture = allCultures.FindCulture(newInfo); string conflictingVariable = null; if (conflictingCulture.languageCode.ToLower() == newInfo.languageCode.ToLower()) { conflictingVariable = "Language Code:" + newInfo.languageCode; } else if (conflictingCulture.englishName.ToLower() == newInfo.englishName.ToLower()) { conflictingVariable = "English Name:" + newInfo.englishName; } showHelpMessage = true; helpMessageType = MessageType.Error; helpMessage = string.Format("Failed to create language!\n Conflicting variable - {0}\n\n", conflictingVariable); helpMessage += string.Format("Conflicting Culture \n Language Code: {0}\n English Name:{1}\n Native Name:{2}", conflictingCulture.languageCode, conflictingCulture.englishName, conflictingCulture.nativeName); } } if (showHelpMessage) { EditorGUILayout.HelpBox(helpMessage, helpMessageType); } } }
void Initialize() { if (undoManager == null) { // Instantiate Undo Manager undoManager = new HOEditorUndoManager(this, "Smart Localization - Edit Root Language Window"); } if (keyTypes == null) { //Get the different key types List <string> enumNames = new List <string>(Enum.GetNames(typeof(LocalizedObjectType))); if (enumNames.Contains("INVALID")) { enumNames.Remove("INVALID"); } keyTypes = enumNames.ToArray(); } if (changedRootKeys == null) { changedRootKeys = new List <SerializableStringPair>(); } if (changedRootValues == null) { changedRootValues = new List <SerializableLocalizationObjectPair>(); } if (parsedRootValues == null) { parsedRootValues = new Dictionary <string, LocalizedObject>(); } if (parsedRootValues.Count < 1) { SetRootValues(LanguageHandlerEditor.LoadParsedLanguageFile(null, true)); } settingsList.Clear(); settingsList.Add("CONVERTLINEBREAK"); settingsList.Add("GENERAL"); settingsList.Add("SEARCH"); settingsList.Add("IMPORT"); settingsAdaptor = new SettingsListAdaptor(settingsList, DrawSettingsItem, 20); settingsContextMenu = new SettingsMenuControl(); localizedObjectAdaptor = new LocalizedObjectListAdaptor(changedRootValues, changedRootKeys, DrawRootPair, 17); if (localizedObjectContextMenu != null) { localizedObjectContextMenu.ClearEvents(); } localizedObjectContextMenu = new LocalizedObjectMenuControl(OnKeyDeleted, OnKeyAdded); listColumns = new EditorColumns(0.1f); listColumns.AddColumn("Type", 0.1f); listColumns.AddColumn("Key", 0.45f); listColumns.AddColumn("Comment", 0.45f); listColumns.RecalculateColumnWidths(); if (EditorPrefs.HasKey(CollapseMultilineSaveKey)) { collapseMultilineFields = EditorPrefs.GetBool(CollapseMultilineSaveKey); } GUIUtility.keyboardControl = 0; }