public static void SaveTranslation(string languageCode, IEnumerable <TranslationItemWithCategory> items, string filename)
{
Translation foreignTranslation = new Translation {
GitExVersion = GitCommands.Settings.GitExtensionsVersionString,
LanguageCode = languageCode
};
foreach (TranslationItemWithCategory translateItem in items)
{
if (translateItem.Status == TranslationType.Obsolete &&
(String.IsNullOrEmpty(translateItem.TranslatedValue) || String.IsNullOrEmpty(translateItem.NeutralValue)))
{
continue;
}
TranslationItem ti = translateItem.GetTranslationItem().Clone();
if (ti.Status == TranslationType.New)
{
ti.Status = TranslationType.Unfinished;
}
Debug.Assert(!string.IsNullOrEmpty(ti.Value) || ti.Status != TranslationType.Translated);
ti.Value = ti.Value ?? String.Empty;
Debug.Assert(ti.Status != TranslationType.Translated || translateItem.IsSourceEqual(ti.Source));
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category).AddTranslationItem(ti);
}
TranslationSerializer.Serialize(foreignTranslation, filename);
}
private async void BroadcastMessageAsync(string message)
{
string languages = null;
bool doTranslate = Convert.ToBoolean(ConfigurationManager.AppSettings["TranslateServerEnabled"]);
var text = message.Substring(BroadcastMessagePrefix.Length);
if (doTranslate)
{
languages = GetLanguages(text, Convert.ToInt32(ConfigurationManager.AppSettings["TranslateCount"]));
TranslationItem item = await DoTranslation(text, languages);
// only a single translation item so use index [0]
text = item.Text[0];
}
if (!string.IsNullOrWhiteSpace(text))
{
foreach (var client in _sockets)
{
var languageKey = doTranslate ? $" as [{languages}]" : string.Empty;
Console.WriteLine($"broadcasting to {client.Value.Guid.ToString()}{languageKey}: " + text);
client.Value.WriteString(text);
}
BroadcastGpioSignal();
}
}
public Task SetItemRating(TranslationItem item, string fromLang, string toLang)
{
return
(Task.Run(async() =>
{
Thread.Sleep(2000);
int index;
ObservableCollection <TranslationItem> translItems = await GetTranslations(item.Translation, fromLang, toLang);
var zzz = translItems.FirstOrDefault(z => z.Translation == item.OriginalWord && z.LangPart == item.LangPart);
index = zzz == null ? -1 : (100 - translItems.IndexOf(zzz));
item.Rating = index;
}));
//return;
//return
// Task.Run(() =>
// {
// var item1 = item;
// Random rnd = new Random(item.Translation.Length);
// int delay = rnd.Next(1000, 10000);
// Thread.Sleep(delay);
// Random rnd1 = new Random(delay);
// int res = rnd.Next(1, 15) + rnd1.Next(0, 15);
// item.Rating = delay;
// return delay; //res;
// });
}
/// <returns>null if not found.</returns>
private string LookupText(string langtag, string msgkey)
{
// Note that there is no need to serialize access to System.Web.HttpRuntime.Cache when just reading from it.
//
var messages = (ConcurrentDictionary <string, TranslationItem>)System.Web.HttpRuntime.Cache[GetCacheKey(langtag)];
TranslationItem message = null;
//we need to populate the cache
if (messages == null)
{
LoadMessagesIntoCache(langtag);
messages = (ConcurrentDictionary <string, TranslationItem>)System.Web.HttpRuntime.Cache[GetCacheKey(langtag)];
}
// Normalize any CRLF in the msgid i.e. to just LF.
// PO only support LF so we expect strings to be stored in the repo in that form.
// NB: we test Contains before doing Replace in case string.Replace allocs a new
// string even on no change. (This method is called very often.)
if (msgkey.Contains("\r\n"))
{
msgkey = msgkey.Replace("\r\n", "\n");
}
if (messages == null ||
!messages.TryGetValue(msgkey, out message) ||
!message.Message.IsSet())
{
return(null);
}
return(message.Message);
}
public void AddTranslationItem(TranslationItem translationItem)
{
if (string.IsNullOrEmpty(translationItem.Name))
throw new InvalidOperationException("Cannot add translationitem without name");
TranslationItems.Add(translationItem);
}
public void MergeTranslation(IDictionary <string, TemplateItem> src, Translation dst)
{
// Our purpose here is to merge newly parsed message items (src) with those already stored in a translation repo (dst).
// 1. Where an orphan msgid is found (present in the dst but not the src) we update it in the dst to remove all references.
// 2. Where a src msgid is missing from dst, we simply ADD it to dst.
// 3. Where a src msgid is present in dst, we update the item in the dst to match the src (references, comments, etc.).
//
// 1.
// Simply remove all references from dst items, for now.
foreach (TranslationItem dstItem in dst.Items.Values)
{
dstItem.References = null;
}
// 2. and 3.
foreach (TemplateItem srcItem in src.Values)
{
TranslationItem dstItem = dst.Items.GetOrAdd(srcItem.MsgKey, k => new TranslationItem {
MsgKey = srcItem.MsgKey
});
dstItem.MsgId = srcItem.MsgId;
dstItem.References = srcItem.References;
dstItem.ExtractedComments = srcItem.Comments;
}
// Persist changes.
_repository.SaveTranslation(dst);
}
public async Task <IActionResult> PutTranslationItem(string id, TranslationItem translationItem)
{
if (id != translationItem.Id)
{
return(BadRequest());
}
_context.Entry(translationItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TranslationItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public TranslationItemExists()
{
translationItem = fixture.Create <TranslationItem>();
translationItem.Language = currentLanguage;
context.TranslationItems.Add(translationItem);
context.SaveChanges();
}
private void gridViewUI_ShowingEditor(object sender, CancelEventArgs e)
{
TranslationItem ti = (TranslationItem)gridViewUI.GetRow(gridViewUI.FocusedRowHandle);
if (ti != null)
{
if (gridViewUI.FocusedColumn == gridColumnFrom)
{
if (_fromLanguageId <= 0)
{
e.Cancel = true;
}
}
else
{
if (gridViewUI.FocusedColumn == gridColumnTo)
{
if (_toLanguageId <= 0)
{
e.Cancel = true;
}
}
}
}
}
public async Task <ActionResult <TranslationItem> > PostTranslationItem(TranslationItem translationItem)
{
_context.TranslationItems.Add(translationItem);
await _context.SaveChangesAsync();
//return CreatedAtAction("GetTranslationItem", new { id = translationItem.Id }, translationItem);
return(CreatedAtAction(nameof(GetTranslationItem), new { id = translationItem.Id }, translationItem));
}
public Task <int> GetRating(TranslationItem item, string fromLang, string toLang)
{
return
(Task.Run(async() =>
{
return 1;
}));
}
public static TranslationItemDto Construct(TranslationItem translationItem)
{
return(new TranslationItemDto
{
Key = translationItem.Key,
Value = translationItem.Value
});
}
public TranslationItem(TranslationItem copyItem)
{
Header = copyItem.Header;
Text = copyItem.Text;
OriginalText = copyItem.OriginalText;
TranslationSource = copyItem.TranslationSource;
RequestSourceLanguage = copyItem.RequestSourceLanguage;
DestinationLanguage = copyItem.DestinationLanguage;
_textWithOverflow = null;
}
public TranslationItem(TranslationItem copyItem)
{
Header = copyItem.Header;
Text = copyItem.Text;
OriginalText = copyItem.OriginalText;
TranslationSource = copyItem.TranslationSource;
RequestSourceLanguage = copyItem.RequestSourceLanguage;
DestinationLanguage = copyItem.DestinationLanguage;
_textWithOverflow = null;
}
public ObservableTranslationItem(TranslationItem item)
{
this.Id = item.Id;
this.Name = item.Name;
this.Translator = item.Translator;
this.Exists = item.Exists;
this.LocalPath = Path.Combine(FileUtils.GetQuranDatabaseDirectory(), item.Filename);
_isCompressed = item.Compressed;
_serverUrl = item.Url;
}
protected static TranslationItem AddLanguageVersionToTranslationItem([NotNull] ContentReference contentLink, [NotNull] string translation, [NotNull] LanguageSelector languageSelector)
{
// Create the base language version
TranslationItem translationItem = CmsContext.CreateLanguageVersionOfContent <TranslationItem>(
contentLink, languageSelector);
// Change the properties that need changing for this version.
translationItem.Translation = translation;
return(translationItem);
}
public Dictionary <String, TranslationItem> Extract()
{
String currLang = "";
foreach (String f in otherFiles)
{
if (f.Contains(".es."))
{
currLang = "Spanish";
}
else if (f.Contains(".pt."))
{
currLang = "Portuguese";
}
else if (f.Contains(".fr."))
{
currLang = "French";
}
else if (f.Contains(".de."))
{
currLang = "German";
}
else if (f.Contains(".nl."))
{
currLang = "Dutch";
}
else
{
currLang = "English";
}
XmlDocument document = new XmlDocument();
document.Load(f);
//XmlNode root = document.GetElementsByTagName("resources")[0];
XmlNodeList elemList = document.GetElementsByTagName("string");
//XmlNodeList elemList = document.GetElementsByTagName("resources").;
for (int i = 0; i < elemList.Count; i++)
{
if (translationItems.ContainsKey(elemList[i].Attributes[0].Value))
{
TranslationItem item = translationItems[elemList[i].Attributes[0].Value];
item.GetType().GetProperty(currLang).SetValue(item, elemList[i].ChildNodes[1].InnerText, null);
}
else
{
TranslationItem item = new TranslationItem(elemList[i].Attributes[0].Value);
item.key = elemList[i].Attributes[0].Value;
item.GetType().GetProperty(currLang).SetValue(item, elemList[i].InnerText);
translationItems.Add(elemList[i].Attributes[0].Value, item);
}
}
}
return(translationItems);
}
public async Task <ActionResult> EditAsync([Bind("Id,Key,Language")] TranslationItem item)
{
if (ModelState.IsValid)
{
await _cosmosDbService.UpdateItemAsync(item.Id, item);
return(RedirectToAction("Index"));
}
return(View(item));
}
public async Task <ActionResult> CreateAsync([Bind("Id,Key,Language")] TranslationItem item)
{
if (ModelState.IsValid)
{
item.Id = Guid.NewGuid().ToString();
await _cosmosDbService.AddItemAsync(item);
return(RedirectToAction("Index"));
}
return(View(item));
}
public TranslationItemExists()
{
context.Database.EnsureDeleted();
_translationItem = fixture.Create <TranslationItem>();
_translationItem.Language = currentLanguage;
context.TranslationItems.Add(_translationItem);
context.SaveChanges();
_translationItem = context.TranslationItems.FirstOrDefault();
}
public Task <int> GetRating(TranslationItem item, string fromLang, string toLang)
{
return
(Task.Run(async() =>
{
int index;
ObservableCollection <TranslationItem> translItems = await GetTranslations(item.Translation, fromLang, toLang);
var zzz = translItems.FirstOrDefault(z => z.Translation == item.OriginalWord && z.LangPart == item.LangPart);
index = zzz == null ? -1 : (100 - translItems.IndexOf(zzz));
return index;
}));
}
protected static TranslationItem CreateTranslationItem([NotNull] string originalText, [NotNull] string translation, [NotNull] ContentReference parentLink, [NotNull] LanguageSelector languageSelector)
{
// Create the base item
TranslationItem translationItem = CmsContext.CreateContent <TranslationItem>(
originalText, parentLink);
// Set the additional properties for this type.
translationItem.OriginalText = originalText;
translationItem.Translation = translation;
return(translationItem);
}
private void SaveAs()
{
var foreignTranslation = new Translation {
LanguageCode = GetSelectedLanguageCode()
};
foreach (TranslateItem translateItem in translate)
{
string value = translateItem.TranslatedValue ?? String.Empty;
TranslationItem ti = new TranslationItem(translateItem.Name, translateItem.Property,
translateItem.NeutralValue, value);
ti.Status = translateItem.Status;
if (ti.Status == TranslationType.Obsolete &&
(String.IsNullOrEmpty(value) || String.IsNullOrEmpty(translateItem.NeutralValue)))
{
continue;
}
if (string.IsNullOrEmpty(value))
{
if (ti.Status == TranslationType.Translated || ti.Status == TranslationType.New)
{
ti.Status = TranslationType.Unfinished;
}
}
else
{
// TODO: Support in form
if (ti.Status == TranslationType.Unfinished)
{
ti.Status = TranslationType.Translated;
}
}
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category).AddTranslationItem(ti);
}
using (var fileDialog =
new SaveFileDialog
{
Title = saveAsText.Text,
FileName = translations.Text + ".xml",
Filter = saveAsTextFilter.Text + "|*.xml",
DefaultExt = ".xml",
AddExtension = true
})
{
if (fileDialog.ShowDialog(this) == DialogResult.OK)
{
TranslationSerializer.Serialize(foreignTranslation, fileDialog.FileName);
changesMade = false;
}
}
}
public static void SaveTranslation(string languageCode, IEnumerable <TranslationItemWithCategory> items, string filename)
{
var foreignTranslation = new Translation(GitCommands.AppSettings.GitExtensionsVersionString, languageCode);
foreach (TranslationItemWithCategory translateItem in items)
{
var item = translateItem.GetTranslationItem();
var ti = new TranslationItem(item.Name, item.Property, item.Source, item.Value);
ti.Value = ti.Value ?? String.Empty;
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category).Body.AddTranslationItem(ti);
}
TranslationSerializer.Serialize(foreignTranslation, filename);
}
private async Task <TranslationItem> DoTranslation(string text, string lang)
{
if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(lang))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
string[] parts = lang.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim().ToLower())
.ToArray();
var newText = text;
TranslationItem item = null;
for (int i = 0; i < parts.Length - 1; ++i)
{
string part = $"{parts[i]}-{parts[i + 1]}";
UriBuilder builder = new UriBuilder("https://translate.yandex.net/api/v1.5/tr.json/translate");
builder.Query = $"key=trnsl.1.1.20161115T000752Z.e4ef69f185b49000.8af2c89b99ea6cf6063ad452099e5f3e999e4487&text={newText}&lang={part}";
HttpResponseMessage response = await client.GetAsync(builder.Uri);
if (response.IsSuccessStatusCode)
{
item = await response.Content.ReadAsAsync <TranslationItem>();
newText = item.Text[0];
// adjust the language returned since right now it holds just the last translation
item.Language = lang;
}
}
var uri = Request.GetOwinContext().Request.Uri;
var host = Request.GetOwinContext().Request.RemoteIpAddress;
Console.WriteLine($" Translated uri: {uri}");
Console.WriteLine($"Translated from: {host}");
Console.WriteLine($"Translated lang: {lang}");
Console.WriteLine($"Translated from: {text}");
Console.WriteLine($" Translated to: {item.Text[0]}");
Console.WriteLine();
return(item);
}
private static void HandleXmlFileModify(TranslationItem tItem)
{
if (mViewModel.file != null)
{
IEnumerable <XElement> fileElemets = mViewModel.file.Elements();
foreach (var file in fileElemets)
{
IEnumerable <XElement> thBody = file.Elements().Elements();
foreach (var itm in thBody) // <trans-unit>
{
//If it finds the item you want to modify
if (int.Parse(itm.FirstAttribute.Value) == tItem.Id)
{
List <XElement> transUnit = itm.Elements().ToList();
//Checks if it is intended for translation
if (itm.Attributes().ToList().Count < 3 ? true : itm.Attributes().ToList()[2].Value != "no")
{
//If the item isnt translated fills in the original text
if (!string.IsNullOrWhiteSpace(tItem.Translated))
{
transUnit[1].SetValue(tItem.Translated);
}
else
{
transUnit[1].SetValue(tItem.Original);
}
//Updates the 'translated' attribute to the saved items value
if (tItem.IsTranslated)
{
transUnit[1].FirstAttribute.SetValue("translated");
}
else
{
transUnit[1].FirstAttribute.SetValue("needs-translation");
}
}
break;
}
}
}
}
else
{
DialogManager.Show("You havent selected a file", "Warning");
}
}
public async Task <ActionResult> DeleteAsync(string id)
{
if (id == null)
{
return(BadRequest());
}
TranslationItem item = await _cosmosDbService.GetItemAsync(id);
if (item == null)
{
return(NotFound());
}
return(View(item));
}
private void SaveAs()
{
var foreignTranslation = new Translation {
LanguageCode = GetSelectedLanguageCode()
};
if (foreignTranslation.LanguageCode != null)
{
foreach (TranslateItem translateItem in translate)
{
//Item is not translated (yet), skip it
if (string.IsNullOrEmpty(translateItem.TranslatedValue))
{
continue;
}
TranslationItem ti = new TranslationItem(translateItem.Name, translateItem.Property, translateItem.TranslatedValue);
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category).AddTranslationItem(ti);
}
}
else
{
// English language
foreach (TranslateItem translateItem in translate)
{
TranslationItem ti = new TranslationItem(translateItem.Name, translateItem.Property, translateItem.NeutralValue);
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category).AddTranslationItem(ti);
}
}
var fileDialog =
new SaveFileDialog
{
Title = saveAsText.Text,
FileName = translations.Text + ".xml",
Filter = saveAsTextFilter.Text + "|*.xml",
DefaultExt = ".xml",
AddExtension = true
};
if (fileDialog.ShowDialog(this) == DialogResult.OK)
{
TranslationSerializer.Serialize(foreignTranslation, fileDialog.FileName);
changesMade = false;
}
}
public TranslationMultipleChoices CreateCardMultipleChoices(TranslationItem word, int wrongAnswerCount)
{
var wrongAnswers =
Translations
.Where(w => w.From != word.From)
.OrderBy(ob => _random.Next())
.Select(s => s.To)
.Take(wrongAnswerCount)
.ToList();
wrongAnswers.Add(word.To);
var allAnswers = wrongAnswers
.OrderBy(ob => _random.Next())
.ToList();
return(new TranslationMultipleChoices {
Choices = allAnswers, Answer = word.To, Translation = word.From
});
}
public async Task <TranslationDictionary> ReadKindleMateExportedDictionaryAsync(string kindleMateFile)
{
var dict = new TranslationDictionary
{
Translations = new List <TranslationItem>()
};
var content = File.ReadAllLines(kindleMateFile);
bool isWord = true;
var word = "";
int emptyLineNum = 0;
TranslationItem translationItem = new TranslationItem();
foreach (var line in content)
{
if (string.IsNullOrWhiteSpace(line))
{
isWord = true;
emptyLineNum++;
word = "";
if (emptyLineNum % 2 == 0)
{
var index = ExistsTranslationItem(dict, translationItem.Word.Text);
if (index == -1)
{
dict.Translations.Add(translationItem);
}
else
{
if (dict.Translations[index].Sentence.Text != translationItem.Sentence.Text)
{
dict.Translations[index].Sentence.Text += translationItem.Sentence.Text;
}
}
isWord = true;
}
continue;
}
if (isWord)
{
var startWord = line.IndexOf("(") + 1;
var endWord = line.IndexOf(")");
word = line[startWord..endWord];
public void AddTranslationItemIfNotExist(TranslationItem translationItem)
{
if (string.IsNullOrEmpty(translationItem.Name))
throw new InvalidOperationException("Cannot add translationitem without name");
TranslationItem ti = GetTranslationItem(translationItem.Name, translationItem.Property);
if (ti == null)
{
if (translationItem.Property == "ToolTipText")
{
ti = GetTranslationItem(translationItem.Name, "Text");
if (ti == null || translationItem.Value != ti.Value)
TranslationItems.Add(translationItem);
}
else
TranslationItems.Add(translationItem);
}
else
Debug.Assert(ti.Value == translationItem.Value);
}
/// <summary>
/// The add element.
/// </summary>
/// <param name="xw">
/// The xmlWriter.
/// </param>
/// <param name="container">
/// The container.
/// </param>
/// <param name="cultureInfo">
/// The culture info.
/// </param>
private void AddElement(XmlWriter xw, ContentReference container, CultureInfo cultureInfo)
{
List <PageData> children =
this.ContentRepository.GetChildren <PageData>(container, new LanguageSelector(cultureInfo.Name)).ToList();
foreach (PageData child in children)
{
TranslationContainer translationContainer = child as TranslationContainer;
if (translationContainer != null)
{
string key = Regex.Replace(
translationContainer.Name.ToLowerInvariant(), @"[^A-Za-z0-9]+", string.Empty);
xw.WriteStartElement(key);
this.AddElement(xw, child.PageLink, cultureInfo);
xw.WriteEndElement();
}
CategoryTranslationContainer categoryTranslationContainer = child as CategoryTranslationContainer;
if (categoryTranslationContainer != null)
{
xw.WriteStartElement("categories");
this.AddCategoryElement(xw, child.PageLink, cultureInfo);
xw.WriteEndElement();
}
TranslationItem translationItem = child as TranslationItem;
if (translationItem != null)
{
string key = Regex.Replace(
translationItem.OriginalText.ToLowerInvariant(), @"[^A-Za-z0-9]+", string.Empty);
xw.WriteElementString(key, translationItem.Translation);
}
}
}
public static void SaveTranslation(string targetLanguageCode,
IDictionary <string, List <TranslationItemWithCategory> > items, string filename)
{
var ext = Path.GetExtension(filename);
foreach (var pair in items)
{
var foreignTranslation = new TranslationFile(GitCommands.AppSettings.ProductVersion, "en", targetLanguageCode);
foreach (var translateItem in pair.Value)
{
var item = translateItem.GetTranslationItem();
var ti = new TranslationItem(item.Name, item.Property, item.Source, item.Value);
ti.Value = ti.Value ?? String.Empty;
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category)
.Body.AddTranslationItem(ti);
}
var newfilename = Path.ChangeExtension(filename, pair.Key + ext);
TranslationSerializer.Serialize(foreignTranslation, newfilename);
}
}
private static int CompareSort(TranslationItem[] x, TranslationItem[] y)
{
return string.Compare(x[0].StringName, y[0].StringName);
}
public TranslationItemWithCategory(string category, TranslationItem item)
{
Category = category;
_item = item;
}
public TranslationItemWithCategory()
{
_item = new TranslationItem();
}
public static void SaveTranslation(string languageCode, IEnumerable<TranslationItemWithCategory> items, string filename)
{
var foreignTranslation = new Translation(GitCommands.AppSettings.ProductVersion, languageCode);
foreach (TranslationItemWithCategory translateItem in items)
{
var item = translateItem.GetTranslationItem();
var ti = new TranslationItem(item.Name, item.Property, item.Source, item.Value);
ti.Value = ti.Value ?? String.Empty;
foreignTranslation.FindOrAddTranslationCategory(translateItem.Category).Body.AddTranslationItem(ti);
}
TranslationSerializer.Serialize(foreignTranslation, filename);
}
public bool CheckConflictingResource(string language, TranslationItem ti, ref TranslationItem conflict)
{
Dictionary<string, TranslationItem> langResources = _resources[language];
string cmp = (language == "en") ? ti.BaseString : ti.TranslatedString;
foreach (KeyValuePair<string, TranslationItem> kvp in langResources)
{
string s1 = kvp.Key.Trim().ToLowerInvariant();
string s2 = cmp.Trim().ToLowerInvariant();
if ((s1 == s2) || (s1 == s2 + ":") || (s1 + ":" == s2))
{
conflict = kvp.Value;
return true;
}
}
langResources.Add(cmp, ti);
return false;
}
void ResourceValidationDialog_Load(object sender, EventArgs e)
{
Dictionary<string, List<TranslationItem[]>> duplicateTranslations =
new Dictionary<string, List<TranslationItem[]>>();
foreach (string file in _scanAssemblies)
{
if (!duplicateTranslations.ContainsKey("en"))
{
duplicateTranslations["en"] = new List<TranslationItem[]>();
}
TranslationFile tf = new TranslationFile(file, "ro");
foreach (TranslationItem ti in tf.Items.Values)
{
try
{
TranslationItem conflict = null;
if (CheckConflictingResource("en", ti, ref conflict))
{
List<TranslationItem[]> lst = duplicateTranslations["en"];
TranslationItem[] pair = new TranslationItem[2] { ti, conflict };
lst.Add(pair);
}
}
catch
{
}
}
foreach (string lang in TranslationFile.SupportedLanguages)
{
if (!duplicateTranslations.ContainsKey(lang))
{
duplicateTranslations[lang] = new List<TranslationItem[]>();
}
tf = new TranslationFile(file, lang);
foreach (TranslationItem ti in tf.Items.Values)
{
try
{
TranslationItem conflict = null;
if (CheckConflictingResource(lang, ti, ref conflict))
{
List<TranslationItem[]> lst = duplicateTranslations[lang];
TranslationItem[] pair = new TranslationItem[2] { ti, conflict };
lst.Add(pair);
}
}
catch
{
}
}
}
}
tvResults.Nodes.Clear();
foreach (KeyValuePair<string, List<TranslationItem[]>> kvp in duplicateTranslations)
{
TreeNode langNode = tvResults.Nodes.Add(string.Format("{0} - {1} conflict(s) found", kvp.Key, kvp.Value.Count));
List<TranslationItem[]> lst = null;
try
{
lst = kvp.Value.ToList();
lst.Sort(CompareSort);
}
catch
{
}
foreach (TranslationItem[] cds in lst)
{
TreeNode conflictNode = langNode.Nodes.Add(cds[0].StringName);
conflictNode.Nodes.Add(cds[0].ToString());
conflictNode.Nodes.Add(cds[1].ToString());
}
}
//tvResults.ExpandAll();
}
private void OnNewEntry(object sender, EventArgs e)
{
EntryNameDialog dlg = new EntryNameDialog("TXT_ENTRY_NAME", "", "", chkReadOnly.Checked, cmbLanguage.Text);
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
TranslationItem ti = new TranslationItem(string.Empty);
ti.StringName = dlg.EntryName;
ti.BaseString = dlg.EnglishString;
ti.TranslatedString = dlg.TranslatedString;
_tf.Items.Add(ti.StringName, ti);
ListViewItem item = new ListViewItem(new string[]
{
ti.StringName, ti.BaseString, ti.TranslatedString
});
item.Tag = ti;
lvTranslations.Items.Add(item);
lvTranslations.SelectedItems.Clear();
item.Selected = true;
lvTranslations.EnsureVisible(item.Index);
}
}
