protected virtual void UpdatePeer(Text peer, TranslatableText text)
{
var translator = Context?.Translator;
var value = translator == null ? text.Text : text.Translate(translator);
peer.text = value;
}
public virtual void Reset(View view)
{
TranslatableText.Reset(view);
Text.Reset(view);
FontFamily.Reset(view);
TextColor.Reset(view);
PointSize.Reset(view);
TextShadow.Reset(view);
}
public virtual void Reset(View view)
{
TranslatableText?.Reset(view);
Text?.Reset(view);
FontFamily?.Reset(view);
TextColor?.Reset(view);
PointSize?.Reset(view);
PixelSize?.Reset(view);
TextShadow?.Reset(view);
}
public TranslatableText GetTranslatableForLabel(TMP_Text label)
{
TranslatableText result = null;
if (labelTextMap != null && labelTextMap.ContainsKey(label))
{
result = labelTextMap[label];
}
return(result);
}
public DropdownItem(
string key, TranslatableText label, Sprite image = null)
{
Assert.IsNotNull(key, "key != null");
Assert.IsNotNull(label, "label != null");
_key = key;
_label = label;
_image = image;
}
public void Reset(View view)
{
TranslatableText.Reset(view);
Text.Reset(view);
FontFamily.Reset(view);
TextColor.Reset(view);
PointSize.Reset(view);
TranslatablePlaceholderText.Reset(view);
PlaceholderTextColor.Reset(view);
PrimaryCursorColor.Reset(view);
}
public void Reset(View view)
{
TranslatableText?.Reset(view);
Text?.Reset(view);
FontFamily?.Reset(view);
TextColor?.Reset(view);
PointSize?.Reset(view);
PixelSize?.Reset(view);
TranslatablePlaceholderText?.Reset(view);
TranslatablePlaceholderTextFocused?.Reset(view);
PlaceholderTextColor?.Reset(view);
PrimaryCursorColor?.Reset(view);
}
private void UpdatePlaceholder(TranslatableText text)
{
if (PeerPlaceholder == null)
{
return;
}
UpdatePeer(PeerPlaceholder, text);
var empty = string.IsNullOrEmpty(text.Text) && string.IsNullOrEmpty(text.TextKey);
PeerPlaceholder.gameObject.SetActive(!empty);
}
private TranslatableText FindByOriginalContent(string original)
{
TranslatableText result = null;
foreach (TranslatableText item in translatablesDatabase.translatables)
{
if (original.Equals(item.Text) || (!caseSensitive && original.ToLowerInvariant().Equals(item.Text.ToLowerInvariant())))
{
result = item;
break;
}
}
return(result);
}
public override int GetHashCode()
{
return(TranslatableText.GetHashCode());
}
public UntranslatedText(string text, bool templatizeByNumbers, bool removeInternalWhitespace)
{
OriginalText = text;
if (templatizeByNumbers)
{
TemplatedText = text.TemplatizeByNumbers();
if (TemplatedText != null)
{
text = TemplatedText.Template;
}
}
int i = 0;
int firstNonWhitespace = 0;
int lastNonWhitespace = 0;
StringBuilder leadingBuilder = null;
while (i < text.Length && char.IsWhiteSpace(text[i]))
{
if (leadingBuilder == null)
{
leadingBuilder = new StringBuilder(64);
}
leadingBuilder.Append(text[i]);
i++;
}
firstNonWhitespace = i;
if (firstNonWhitespace != 0)
{
LeadingWhitespace = leadingBuilder?.ToString();
}
i = text.Length - 1;
StringBuilder trailingBuilder = leadingBuilder;
if (trailingBuilder != null)
{
trailingBuilder.Length = 0;
}
while (i > -1 && char.IsWhiteSpace(text[i]))
{
if (trailingBuilder == null)
{
trailingBuilder = new StringBuilder(64);
}
trailingBuilder.Append(text[i]);
i--;
}
lastNonWhitespace = i;
if (lastNonWhitespace != text.Length - 1)
{
TrailingWhitespace = trailingBuilder?.Reverse().ToString();
}
// trim internals of 'text'
if (removeInternalWhitespace && Settings.WhitespaceRemovalStrategy == WhitespaceHandlingStrategy.TrimPerNewline)
{
StringBuilder builder = trailingBuilder;
if (builder != null)
{
builder.Length = 0;
}
else if (builder == null)
{
builder = new StringBuilder(64);
}
if (LeadingWhitespace != null)
{
builder.Append(LeadingWhitespace);
}
int whitespaceStart = -1;
for (i = firstNonWhitespace; i <= lastNonWhitespace; i++)
{
var c = text[i];
if (c == '\n')
{
// find first non-whitespace
int u = i - 1;
while (u > firstNonWhitespace && char.IsWhiteSpace(text[u]))
{
u--;
}
int o = i + 1;
while (o < lastNonWhitespace && char.IsWhiteSpace(text[o]))
{
o++;
}
u++;
o--;
int l = o - u;
char lastCharAdded = default(char);
if (l > 0)
{
char currentWhitespaceChar = text[u];
bool addedCurrentWhitespace = false;
u++;
for (int k = u; k <= o; k++)
{
var ch = text[k];
// keep repeating whitespace
if (ch == currentWhitespaceChar)
{
if (!addedCurrentWhitespace)
{
builder.Append(currentWhitespaceChar);
addedCurrentWhitespace = true;
}
builder.Append(ch);
lastCharAdded = ch;
}
else
{
addedCurrentWhitespace = false;
currentWhitespaceChar = ch;
}
}
}
// we know we have just handled a newline
// now we need to check if the last character added is a whitespace character
// if it is not, we should add a space
if (Settings.UsesWhitespaceBetweenWords)
{
if (!char.IsWhiteSpace(lastCharAdded))
{
if (builder.Length > 0 && builder[builder.Length - 1] != ' ')
{
builder.Append(' ');
}
}
}
i = o;
whitespaceStart = -1;
}
else if (!char.IsWhiteSpace(c))
{
if (whitespaceStart != -1)
{
// add from whitespaceStart to i - 1 of characters
for (int b = whitespaceStart; b < i; b++)
{
builder.Append(text[b]);
}
whitespaceStart = -1;
}
builder.Append(c);
}
else
{
// is whitespace char different from \n
if (whitespaceStart == -1)
{
whitespaceStart = i;
}
}
}
if (TrailingWhitespace != null)
{
builder.Append(TrailingWhitespace);
}
TranslatableText = builder.ToString();
}
else
{
TranslatableText = text;
}
int leadingWhitespaceCount = LeadingWhitespace != null ? LeadingWhitespace.Length : 0;
int trailingWhitespaceCount = TrailingWhitespace != null ? TrailingWhitespace.Length : 0;
if (leadingWhitespaceCount > 0 || trailingWhitespaceCount > 0)
{
TrimmedTranslatableText = TranslatableText.Substring(leadingWhitespaceCount, TranslatableText.Length - trailingWhitespaceCount - leadingWhitespaceCount);
}
else
{
TrimmedTranslatableText = TranslatableText;
}
}
public override void OnInspectorGUI()
{
if (database.translatables == null)
{
database.translatables = new List <TranslatableText>();
}
database.isTranslation = EditorGUILayout.ToggleLeft("is a Translation?", database.isTranslation, GUILayout.Width(180));
if (database.isTranslation)
{
TranslatableTextDatabase auxDB = (TranslatableTextDatabase)EditorGUILayout.ObjectField("Original Database", database.original, typeof(TranslatableTextDatabase), false);
if (auxDB != null && !auxDB.Equals(database))
{
database.original = auxDB;
}
}
if (database.isTranslation && (database.original == null || database.original.GetTexts() == null))
{
GUILayout.Label("You need to specify the original database for this translation and it must contain at least one item");
return;
}
if (GUILayout.Button("Add New", GUILayout.Width(80)))
{
database.translatables.Add(new TranslatableText());
}
for (int i = 0; i < database.translatables.Count; i++)
{
TranslatableText item = database.translatables[i];
EditorGUILayout.LabelField(new GUIContent("Translation Key: " + item.translationKey, "Internal key used to match the original with the translations"));
if (database.isTranslation)
{
EditorGUILayout.LabelField("Original Translation Key: " + ((item.original != null)?item.original.translationKey:""));
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Original", GUILayout.Width(50));
int selected = database.original.GetIndexByTranslationKey(item.translationKey) + 1;
string[] displayOpts = PrependOption("<None>", database.original.GetTexts());
selected = EditorGUILayout.IntPopup(selected, displayOpts, GetIndexes(displayOpts.Length), GUILayout.Width(100));
if (selected > 0)
{
item.original = database.original.translatables[selected - 1];
item.translationKey = item.original.translationKey;
}
EditorGUILayout.EndHorizontal();
}
if (string.IsNullOrEmpty(item.translationKey) && !database.isTranslation)
{
item.translationKey = "text-" + ShortGuid.NewGuid();
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Text", GUILayout.Width(50));
item.Text = EditorGUILayout.TextField(item.Text, GUILayout.Width(300));
bool removed = false;
if (GUILayout.Button("X", GUILayout.Width(20)))
{
database.translatables.RemoveAt(i);
removed = true;
}
EditorGUILayout.EndHorizontal();
if (!removed)
{
database.translatables[i] = item;
}
}
EditorUtility.SetDirty(database);
}
private void OnWizardCreate()
{
if (translatablesDatabase == null)
{
EditorUtility.DisplayDialog("Error", "You need to select the translatables database", "OK");
return;
}
if (translatablesDatabase.isTranslation && translatablesDatabase.original != null)
{
// Instead of the original database, a translation was chosen, but we can set it to the right one.
translatablesDatabase = translatablesDatabase.original;
}
TranslatableTextDatabase databaseToSave = null;
string path = EditorUtility.OpenFilePanelWithFilters("Open label translation file", "", new string[] { "Text file", "txt" });
if (path.Length != 0)
{
using (StreamReader reader = new StreamReader(path))
{
databaseToSave = CreateInstance <TranslatableTextDatabase>();
databaseToSave.original = translatablesDatabase;
databaseToSave.isTranslation = true;
databaseToSave.translatables = new List <TranslatableText>();
Regex regex = new Regex(@"^(.+?)(?: *):(?: *)(.*)$");
int lineCount = 0;
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
lineCount++;
// Ignore comments and empty lines
if (line.StartsWith("//") || line.Trim().Length == 0)
{
continue;
}
if (regex.IsMatch(line))
{
Match m = regex.Match(line);
string originalContent = m.Groups[1].Value;
TranslatableText originalText = FindByOriginalContent(originalContent);
if (originalText == null)
{
EditorUtility.DisplayDialog("Error", "The original text for a label couldn't be found. Aborting", "OK");
return;
}
string translation = m.Groups[2].Value;
TranslatableText translatedText = new TranslatableText();
translatedText.original = originalText;
translatedText.translationKey = originalText.translationKey;
translatedText.Text = translation;
databaseToSave.translatables.Add(translatedText);
}
else
{
Debug.LogWarningFormat("LabelTranslationImporter: The line number {0} doesn't matches the format", lineCount);
}
}
}
}
else
{
Debug.LogWarning("LabelTranslationImporter: No input file selected. Process aborted");
return;
}
if (databaseToSave != null)
{
string baseFolder = "Resources/" + localeSettings.baseFolder + "/" + locale.langCode + "/Texts";
string targetDirectory = CreateIntermediateFolders(baseFolder);
AssetDatabase.CreateAsset(databaseToSave, targetDirectory + "/TranslatablesDatabase.asset");
AssetDatabase.SaveAssets();
}
}
