/// <summary>
/// Loads the parsed language file.(without the type identifiers)
/// </summary>
public static Dictionary <string, LocalizedObject> LoadParsedLanguageFile(string languageCode, bool isRoot)
{
string fileContents = string.Empty;
string filePath = null;
if (isRoot)
{
filePath = LocalizationWorkspace.ResourcesFolderFilePath() + "/" +
LocalizationWorkspace.rootLanguageName + LocalizationWorkspace.txtFileEnding;
}
else
{
filePath = LocalizationWorkspace.ResourcesFolderFilePath() + "/" +
LocalizationWorkspace.rootLanguageName + "." + languageCode + LocalizationWorkspace.txtFileEnding;
}
if (!FileUtility.ReadFromFile(filePath, out fileContents))
{
Debug.LogError("Failed to read language from file - " + filePath);
}
var loadedLanguageDB = LanguageParser.LoadLanguage(fileContents);
return(new Dictionary <string, LocalizedObject>(loadedLanguageDB));
}
/// <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));
}
/// <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();
}
/// <summary>
/// Returns true if the window should show, returns false if not.
/// If false, it will draw an editor label that says the window is unavailable
/// </summary>
public static bool ShouldShowWindow(bool isAvailableInPlayMode = false)
{
if (Application.isPlaying && !isAvailableInPlayMode)
{
GUILayout.Label("This Smart Localization Window is not available in play mode", EditorStyles.boldLabel);
if (LanguageManager.HasInstance)
{
if (GUILayout.Button("Go to translation window"))
{
TranslateLanguageWindow.ShowWindow(LanguageManager.Instance.GetCultureInfo(LanguageManager.Instance.CurrentlyLoadedCulture.languageCode), null);
}
}
return(false);
}
else if (!LocalizationWorkspace.Exists())
{
GUILayout.Label("There is no localization workspace available in this project", EditorStyles.boldLabel);
if (GUILayout.Button("Create localization workspace"))
{
if (LocalizationWorkspace.Create())
{
return(true);
}
}
return(false);
}
else
{
return(true);
}
}
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 the initial root language file
/// </summary>
public static void CreateRootResourceFile()
{
//Add a dummy value so that the user will see how everything works
Dictionary<string,string> baseDictionary = new Dictionary<string, string>();
baseDictionary.Add("MyFirst.Key", "MyFirstValue");
SaveLanguageFile(baseDictionary, LocalizationWorkspace.RootLanguageFilePath());
}
static void OnPostProcessScene()
{
if (LocalizationWorkspace.Exists() &&
GenerateStorePresence &&
!HasStorePresence)
{
GeneratePresence();
}
}
/// <summary>
/// Gets a SmartCultureInfoCollection with all the cultures not available in this workspace
/// </summary>
/// <param name="allCultures">The list of all the available cultures</param>
/// <returns>A SmartCultureInfoCollection with all the cultures not available in this workspace</returns>
public static SmartCultureInfoCollection GetNonAvailableLanguages(SmartCultureInfoCollection allCultures)
{
SmartCultureInfoCollection nonCreatedLanguages = new SmartCultureInfoCollection();
foreach(SmartCultureInfo cultureInfo in allCultures.cultureInfos)
{
if(!FileUtility.Exists(LocalizationWorkspace.LanguageFilePath(cultureInfo.languageCode)))
{
nonCreatedLanguages.AddCultureInfo(cultureInfo);
}
}
return nonCreatedLanguages;
}
/// <summary>
/// Checks all the created languages and Saves the AvailableCultures xml.
/// </summary>
/// <param name="allCultures">A list of all the available cultures</param>
/// <returns>A list of all the created languages</returns>
public static SmartCultureInfoCollection CheckAndSaveAvailableLanguages(SmartCultureInfoCollection allCultures)
{
SmartCultureInfoCollection createdCultures = new SmartCultureInfoCollection();
foreach(SmartCultureInfo cultureInfo in allCultures.cultureInfos)
{
if(FileUtility.Exists(LocalizationWorkspace.LanguageFilePath(cultureInfo.languageCode)))
{
createdCultures.AddCultureInfo(cultureInfo);
}
}
createdCultures.Serialize(LocalizationWorkspace.AvailableCulturesFilePath());
return createdCultures;
}
static bool CheckStorePresence()
{
string pluginDirectory = "/" + PluginFolderName;
string androidDirectory = pluginDirectory + "/" + AndroidFolderName;
string resourceDirectory = androidDirectory + "/" + ResourceFolderName;
if (DirectoryUtility.ExistsRelative(pluginDirectory) &&
DirectoryUtility.ExistsRelative(androidDirectory) &&
DirectoryUtility.ExistsRelative(resourceDirectory) &&
DirectoryUtility.ExistsRelative(resourceDirectory + "/" + ValuesFolderName) &&
FileUtility.ExistsRelative(resourceDirectory + "/" + ValuesFolderName + "/" + StringsFileName))
{
if (!DoesFileHavePresence(Application.dataPath + "/" + resourceDirectory + "/" + ValuesFolderName + "/" + StringsFileName))
{
return(false);
}
var availableCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.AvailableCulturesFilePath());
foreach (SmartCultureInfo cultureInfo in availableCultures.cultureInfos)
{
if (!IsLanguageSupported(cultureInfo.languageCode))
{
continue;
}
string currentLanguageFolderPath = GetValueFolderPath(resourceDirectory, cultureInfo);
if (!DirectoryUtility.ExistsRelative(currentLanguageFolderPath))
{
return(false);
}
if (!FileUtility.ExistsRelative(currentLanguageFolderPath + "/" + StringsFileName))
{
return(false);
}
else if (!DoesFileHavePresence(Application.dataPath + "/" + currentLanguageFolderPath + "/" + StringsFileName))
{
return(false);
}
}
return(true);
}
return(false);
}
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>Renames the localized file from resources.</summary>
public static void RenameFileFromResources(string key, string newKey, SmartCultureInfo cultureInfo)
{
string languageFolderPath = null;
LocalizedObjectType keyType = LocalizedObject.GetLocalizedObjectType(key);
string cleanKey = LocalizedObject.GetCleanKey(key);
string cleanNewKey = LocalizedObject.GetCleanKey(newKey);
switch (keyType)
{
case LocalizedObjectType.GAME_OBJECT:
languageFolderPath = LocalizationWorkspace.LanguagePrefabsFolderPathRelative(cultureInfo.languageCode) + "/" + cleanKey + LocalizationWorkspace.prefabFileEnding;
break;
case LocalizedObjectType.AUDIO:
languageFolderPath = LocalizationWorkspace.LanguageAudioFolderPathRelative(cultureInfo.languageCode);
break;
case LocalizedObjectType.TEXTURE:
languageFolderPath = LocalizationWorkspace.LanguageTexturesFolderPathRelative(cultureInfo.languageCode);
break;
case LocalizedObjectType.TEXT_ASSET:
languageFolderPath = LocalizationWorkspace.LanguageTextAssetsFolderPathRelative(cultureInfo.languageCode);
break;
case LocalizedObjectType.FONT:
languageFolderPath = LocalizationWorkspace.LanguageFontsFolderPathRelative(cultureInfo.languageCode);
break;
}
if (keyType != LocalizedObjectType.GAME_OBJECT)
{
string fileExtension = FileUtility.GetFileExtension(cleanKey, languageFolderPath);
languageFolderPath += "/" + cleanKey + fileExtension;
}
if (FileUtility.Exists(Application.dataPath + languageFolderPath))
{
AssetDatabase.RenameAsset("Assets" + languageFolderPath, cleanNewKey);
}
AssetDatabase.Refresh();
}
/// <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);
}
}
}
/// <summary> Deletes the localized file from resources.</summary>
public static void DeleteFileFromResources(string key, SmartCultureInfo cultureInfo)
{
string languageFolderPath = string.Empty;
string cleanKey = LocalizedObject.GetCleanKey(key);
LocalizedObjectType keyType = LocalizedObject.GetLocalizedObjectType(key);
switch (keyType)
{
case LocalizedObjectType.GameObject:
languageFolderPath = LocalizationWorkspace.LanguagePrefabsFolderPathRelative(cultureInfo.languageCode) + "/" + cleanKey + LocalizationWorkspace.prefabFileEnding;
break;
case LocalizedObjectType.Audio:
languageFolderPath = LocalizationWorkspace.LanguageAudioFolderPathRelative(cultureInfo.languageCode);
break;
case LocalizedObjectType.Texture:
languageFolderPath = LocalizationWorkspace.LanguageTexturesFolderPathRelative(cultureInfo.languageCode);
break;
case LocalizedObjectType.TextAsset:
languageFolderPath = LocalizationWorkspace.LanguageTextAssetsFolderPathRelative(cultureInfo.languageCode);
break;
case LocalizedObjectType.Font:
languageFolderPath = LocalizationWorkspace.LanguageFontsFolderPathRelative(cultureInfo.languageCode);
break;
}
if (keyType != LocalizedObjectType.GameObject)
{
string fileExtension = FileUtility.GetFileExtension(cleanKey, languageFolderPath);
languageFolderPath += "/" + cleanKey + fileExtension;
}
if (FileUtility.Exists(Application.dataPath + languageFolderPath))
{
AssetDatabase.DeleteAsset("Assets" + languageFolderPath);
}
AssetDatabase.Refresh();
}
/// <summary>
/// Returns if the key selector should be shown.
/// </summary>
/// <returns>Returns if the key selector should be shown.</returns>
public static bool ShouldShowKeySelector()
{
if (Application.isPlaying)
{
GUILayout.Label("Feature not available in play mode.", EditorStyles.miniLabel);
return(false);
}
if (!LocalizationWorkspace.Exists())
{
GUILayout.Label("There is no Smart Localization workspace created", EditorStyles.miniLabel);
//There is no language created
if (GUILayout.Button("Create Workspace"))
{
LocalizationWorkspace.Create();
}
return(false);
}
return(true);
}
void Initialize()
{
if (undoManager == null)
{
undoManager = new HOEditorUndoManager(this, "SmartLocalization-Main");
}
if (availableCultures == null)
{
allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath());
if (allCultures.version != SmartCultureInfoCollection.LatestVersion)
{
LocalizationWorkspace.GenerateCultureInfoCollection(allCultures);
allCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.CultureInfoCollectionFilePath());
}
InitializeCultureCollections();
}
if (EditorPrefs.HasKey(MicrosoftTranslatorIDSaveKey) && EditorPrefs.HasKey(MicrosoftTranslatorSecretSaveKey) && EditorPrefs.HasKey(KeepAuthenticatedSaveKey))
{
mtClientID = EditorPrefs.GetString(MicrosoftTranslatorIDSaveKey);
mtClientSecret = EditorPrefs.GetString(MicrosoftTranslatorSecretSaveKey);
keepTranslatorAuthenticated = EditorPrefs.GetBool(KeepAuthenticatedSaveKey);
}
InitializeTranslator();
generateAndroidPresence = AndroidStorePresenceGenerator.GenerateStorePresence;
generateiOSPresence = IOSStorePresenceGenerator.GenerateStorePresence;
settingsList.Clear();
settingsList.Add("SETTINGS");
settingsList.Add("STOREPRESENCE");
settingsList.Add("AUTOTRANSLATE");
isInitialized = true;
GUIUtility.keyboardControl = 0;
}
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);
}
}
/// <summary> Copies the file into the resources folder. Naming the new asset to KEY </summary>
public static string CopyFileIntoResources(SerializableLocalizationObjectPair objectPair, SmartCultureInfo thisCultureInfo)
{
if(!DirectoryUtility.CheckAndCreate(LocalizationWorkspace.LanguageRuntimeFolderPath(thisCultureInfo.languageCode)))
{
return "";
}
string newFileName = objectPair.keyValue;
string filePath = string.Empty;
string currentAssetPath = string.Empty;
LocalizedObject objectToCopy = objectPair.changedValue;
if(objectToCopy.ObjectType == LocalizedObjectType.AUDIO && objectToCopy.ThisAudioClip != null)
{
filePath = LocalizationWorkspace.LanguageAudioFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisAudioClip);
}
else if(objectToCopy.ObjectType == LocalizedObjectType.TEXTURE && objectToCopy.ThisTexture != null)
{
filePath = LocalizationWorkspace.LanguageTexturesFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisTexture);
}
else if(objectToCopy.ObjectType == LocalizedObjectType.GAME_OBJECT && objectToCopy.ThisGameObject != null)
{
filePath = LocalizationWorkspace.LanguagePrefabsFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisGameObject);
}
else if(objectToCopy.ObjectType == LocalizedObjectType.TEXT_ASSET && objectToCopy.ThisTextAsset != null)
{
filePath = LocalizationWorkspace.LanguageTextAssetsFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisTextAsset);
}
else if(objectToCopy.ObjectType == LocalizedObjectType.FONT && objectToCopy.Font != null)
{
filePath = LocalizationWorkspace.LanguageFontsFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.Font);
}
else
{
return string.Empty;
}
if(!DirectoryUtility.CheckAndCreate(filePath))
{
return "";
}
//Get the fileExtension of the asset
string fileExtension = FileUtility.GetFileExtension(Application.dataPath + currentAssetPath);
if(objectToCopy.ObjectType != LocalizedObjectType.GAME_OBJECT){
//Copy or replace the file to the new path
FileUtil.ReplaceFile(currentAssetPath, filePath + "/" + newFileName + fileExtension);
string metaFile = Application.dataPath.Substring(0, Application.dataPath.Length - "Assets".Length) +
currentAssetPath.Substring(0, currentAssetPath.Length - fileExtension.Length) + fileExtension + ".meta";
if(File.Exists(metaFile))
{
FileUtil.ReplaceFile(metaFile, filePath + "/" + newFileName + fileExtension + ".meta");
}
}
else{
string relativePath = filePath + "/" + newFileName + fileExtension;
relativePath = "Assets" + relativePath.Substring(Application.dataPath.Length);
PrefabUtility.CreatePrefab(relativePath, objectToCopy.ThisGameObject);
}
return AssetDatabase.AssetPathToGUID(currentAssetPath);
}
/// <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;
}
/// <summary>
/// Saves the root language file and updates all the available languages.
/// </summary>
public static void SaveRootLanguageFile(Dictionary<string,string> changedRootKeys, Dictionary<string,string> changedRootValues, SmartCultureInfoCollection availableCultures)
{
//The dictionary with all the final changes
Dictionary<string,string> changedDictionary = new Dictionary<string, string>();
foreach(KeyValuePair<string,string> changedKey in changedRootKeys)
{
if(changedKey.Key == changedKey.Value)
{
//The key is not changed, just add the key and the changed value to the new dictionary
LanguageDictionaryHelper.AddNewKeyPersistent(changedDictionary, changedKey.Key, changedRootValues[changedKey.Key]);
}
else
{
//Add the new key along with the new changed value
LanguageDictionaryHelper.AddNewKeyPersistent(changedDictionary, changedKey.Value, changedRootValues[changedKey.Key]);
}
}
//Look if any keys were deleted,(so that we can delete the created files)
List<string> deletedKeys = new List<string>();
IEnumerable<string> originalKeys = LoadLanguageFile(null, true).Keys;
foreach(string originalKey in originalKeys)
{
bool foundMatch = false;
foreach(KeyValuePair<string,string> changedKey in changedRootKeys)
{
if(originalKey == changedKey.Key)
{
foundMatch = true;
break;
}
}
if(!foundMatch)
{
deletedKeys.Add(originalKey);
}
}
//Save the language file
SaveLanguageFile(changedDictionary, LocalizationWorkspace.RootLanguageFilePath());
//Change all the key values for all the translated languages
var changedCultureValues = new Dictionary<string, string>();
foreach(var cultureInfo in availableCultures.cultureInfos)
{
var currentCultureValues = LoadLanguageFile(cultureInfo.languageCode, false);
foreach(var changedKey in changedRootKeys)
{
string currentValue;
currentCultureValues.TryGetValue(changedKey.Key, out currentValue);
if(currentValue == null)
{
currentValue = "";
}
//If the key is changed, we need to change the asset names as well
if(changedKey.Key != changedKey.Value && currentValue != "")
{
LocalizedObjectType originalType = LocalizedObject.GetLocalizedObjectType(changedKey.Key);
LocalizedObjectType changedType = LocalizedObject.GetLocalizedObjectType(changedKey.Value);
if(originalType != changedType)
{
//If the type is changed, then delete the asset and reset the value
DeleteFileFromResources(changedKey.Key, cultureInfo);
currentValue = "";
}
else
{
//just rename it otherwise
RenameFileFromResources(changedKey.Key, changedKey.Value, cultureInfo);
}
}
LanguageDictionaryHelper.AddNewKeyPersistent(changedCultureValues, changedKey.Value, currentValue);
}
//Save the language file
SaveLanguageFile (changedCultureValues, LocalizationWorkspace.LanguageFilePath(cultureInfo.languageCode));
changedCultureValues.Clear();
//Remove all the deleted files associated with the deleted keys
foreach(string deletedKey in deletedKeys)
{
Debug.Log("Deleted key!:" + deletedKey);
DeleteFileFromResources(deletedKey, cultureInfo);
}
}
}
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);
}
}
}
/// <summary>
/// Generates all the files for store presence
/// </summary>
/// <returns>If the operation was successful</returns>
public static bool GeneratePresence()
{
if (HasStorePresence)
{
return(true);
}
string currentDirectory = Application.dataPath + "/" + PluginFolderName;
if (!DirectoryUtility.CheckAndCreate(currentDirectory))
{
return(false);
}
currentDirectory += "/" + AndroidFolderName;
if (!DirectoryUtility.CheckAndCreate(currentDirectory))
{
return(false);
}
currentDirectory += "/" + ResourceFolderName;
if (!DirectoryUtility.CheckAndCreate(currentDirectory))
{
return(false);
}
//Create the default directory
if (!DirectoryUtility.CheckAndCreate(currentDirectory + "/" + ValuesFolderName))
{
return(false);
}
if (!AppendOrCreateStringsFile(currentDirectory + "/" + ValuesFolderName + "/" + StringsFileName))
{
return(false);
}
var availableCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.AvailableCulturesFilePath());
foreach (SmartCultureInfo cultureInfo in availableCultures.cultureInfos)
{
if (!IsLanguageSupported(cultureInfo.languageCode))
{
continue;
}
string currentLanguageFolderPath = GetValueFolderPath(currentDirectory, cultureInfo);
if (!DirectoryUtility.CheckAndCreate(currentLanguageFolderPath))
{
return(false);
}
if (!AppendOrCreateStringsFile(currentLanguageFolderPath + "/" + StringsFileName))
{
return(false);
}
}
AssetDatabase.Refresh();
return(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 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();
}
public static void OnPostProcessBuild(BuildTarget target, string path)
{
#if UNITY_4_6 || UNITY_4_7
if (target != BuildTarget.iPhone)
#else
if (target != BuildTarget.iOS)
#endif
{
return;
}
if (!GenerateStorePresence)
{
return;
}
const string fileName = "Info.plist";
string fullPath = Path.Combine(path, fileName);
var doc = new XmlDocument();
doc.Load(fullPath);
var dict = FindPlistDictNode(doc);
if (dict == null)
{
Debug.LogError("[Smartlocalization] Error parsing " + fullPath);
return;
}
AddChildElement(doc, dict, "key", "CFBundleLocalizations");
var arrayKey = AddChildElement(doc, dict, "array");
var availableCultures = SmartCultureInfoEx.Deserialize(LocalizationWorkspace.AvailableCulturesFilePath());
foreach (var cultureInfo in availableCultures.cultureInfos)
{
AddChildElement(doc, arrayKey, "string", cultureInfo.languageCode);
}
doc.Save(fullPath);
//the xml writer barfs writing out part of the plist header.
//so we replace the part that it wrote incorrectly here
string textPlist = null;
using (var reader = new StreamReader(fullPath))
{
textPlist = reader.ReadToEnd();
}
int fixupStart = textPlist.IndexOf("<!DOCTYPE plist PUBLIC", System.StringComparison.Ordinal);
if (fixupStart <= 0)
{
return;
}
int fixupEnd = textPlist.IndexOf('>', fixupStart);
if (fixupEnd <= 0)
{
return;
}
string fixedPlist = textPlist.Substring(0, fixupStart);
fixedPlist += "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">";
fixedPlist += textPlist.Substring(fixupEnd + 1);
using (var writer = new StreamWriter(fullPath, false))
{
writer.Write(fixedPlist);
}
}
