private void WriteSegSource(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement("seg-source");
foreach (var segmentPair in transUnit.SegmentPairs)
{
writer.WriteStartElement("mrk");
writer.WriteAttributeString("mtype", "seg");
writer.WriteAttributeString("mid", segmentPair.Id);
//if (segmentPair.IsLocked)
//{
// writer.WriteStartElement("mrk");
// writer.WriteAttributeString("mtype", "protected");
//}
foreach (var element in segmentPair.Source.Elements)
{
WriteSegment(writer, element);
}
//if (segmentPair.IsLocked)
//{
// writer.WriteEndElement(); // mrk
//}
writer.WriteEndElement(); // mrk
}
writer.WriteEndElement(); // seg-source
}
static TransUnit MakeTransUnit(string lang, string englishVal, string val, string id, bool dynamic)
{
var variants = new List <TransUnitVariant> {
new TransUnitVariant {
Lang = lang, Value = val
}
};
if (englishVal != null)
{
variants.Add(new TransUnitVariant {
Lang = "en", Value = englishVal
});
}
var tu = new TransUnit
{
Id = id,
Variants = variants
};
if (dynamic)
{
tu.AddProp(lang, LocalizedStringCache.kDiscoveredDyanmically, "true");
}
return(tu);
}
/// ------------------------------------------------------------------------------------
private void SaveFileForLangId(string langId, bool forceCreation)
{
var tmxDoc = CreateEmptyStringFile();
tmxDoc.Header.SourceLang = langId;
tmxDoc.Header.SetPropValue(LocalizationManager.kAppVersionPropTag, OwningManager.AppVersion);
foreach (var tu in TmxDocument.Body.TransUnits)
{
var tuv = tu.GetVariantForLang(langId);
if (tuv == null)
{
continue;
}
var newTu = new TransUnit {
Id = tu.Id
};
tmxDoc.AddTransUnit(newTu);
newTu.AddOrReplaceVariant(tu.GetVariantForLang(LocalizationManager.kDefaultLang));
newTu.AddOrReplaceVariant(tuv);
newTu.Notes = tu.CopyNotes();
newTu.Props = tu.CopyProps();
}
tmxDoc.Body.TransUnits.Sort(TuComparer);
if (forceCreation || OwningManager.DoesCustomizedTmxExistForLanguage(langId))
{
tmxDoc.Save(OwningManager.GetTmxPathForLanguage(langId, true));
}
}
private bool AddSpaceBetweenSegmentationPosition(TransUnit transUnit, int index)
{
var addSpace = true;
var foundSpaceStart = false;
var foundSpaceEnd = false;
var currentFirstElement = transUnit.SegmentPairs[index].Source.Elements[0];
if (currentFirstElement is ElementText text1)
{
foundSpaceStart = text1.Text.StartsWith(" ");
}
var previous = transUnit.SegmentPairs[index - 1].Source;
var previousLastElement = previous.Elements[previous.Elements.Count - 1];
if (previousLastElement is ElementText text2)
{
foundSpaceEnd = text2.Text.EndsWith(" ");
}
if (foundSpaceStart || foundSpaceEnd)
{
addSpace = false;
}
return(addSpace);
}
private void UpdateTransUnitComment(TransUnit tu, LocalizingInfo locInfo)
{
if (locInfo.DiscoveredDynamically && (tu.GetPropValue(LocalizedStringCache.kDiscoveredDyanmically) != "true"))
{
tu.AddProp(LocalizedStringCache.kDiscoveredDyanmically, "true");
_updated = true;
}
if ((locInfo.UpdateFields & UpdateFields.Comment) != UpdateFields.Comment)
{
return;
}
if ((tu.Notes.Count > 0) && (tu.Notes[0].Text == locInfo.Comment))
{
return;
}
tu.Notes.Clear();
_updated = true;
if (!string.IsNullOrEmpty(locInfo.Comment))
{
tu.AddNote(locInfo.Comment);
}
}
private TransUnit ReadGroup(XmlReader xmlReader)
{
var transUnit = new TransUnit();
var index = 0;
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
if (index == 0 && string.Compare(xmlReader.Name, "group", StringComparison.OrdinalIgnoreCase) == 0)
{
index++;
while (xmlReader.MoveToNextAttribute())
{
if (string.Compare(xmlReader.Name, "id", StringComparison.OrdinalIgnoreCase) == 0)
{
// for polyglot support, the paragraph id is represented by the group id
transUnit.Id = xmlReader.Value;
}
}
}
else if (string.Compare(xmlReader.Name, "trans-unit", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
transUnit.SegmentPairs.Add(ReadTransUnit(xmlReaderSub));
xmlReaderSub.Close();
}
break;
}
}
return(transUnit);
}
private void WriteSourceParagraph(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement("source");
//writer.WriteAttributeString("xml", "space", null, "preserve");
for (var index = 0; index < transUnit.SegmentPairs.Count; index++)
{
var segmentPair = transUnit.SegmentPairs[index];
if (index > 0)
{
var addSpace = AddSpaceBetweenSegmentationPosition(transUnit, index);
if (addSpace)
{
writer.WriteString(" ");
}
}
foreach (var element in segmentPair.Source.Elements)
{
WriteSegment(writer, element);
}
}
writer.WriteEndElement(); // source
}
private TransUnit ReadGroup(XmlReader xmlReader)
{
var transUnit = new TransUnit();
var index = 0;
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
if (index == 0 && string.Compare(xmlReader.Name, "group", StringComparison.OrdinalIgnoreCase) == 0)
{
index++;
}
else if (string.Compare(xmlReader.Name, "trans-unit", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
transUnit = ReadTransUnit(xmlReaderSub);
xmlReaderSub.Close();
}
break;
}
}
return(transUnit);
}
private static void AddFrenchTmx(string folderPath)
{
var doc = new TMXDocument {
Header = { SourceLang = "fr" }
};
// first unit
var variants = new List <TransUnitVariant>
{
new TransUnitVariant {
Lang = "en", Value = "blah"
},
new TransUnitVariant {
Lang = "fr", Value = "blahInFrench"
}
};
var tu = new TransUnit
{
Id = "blahId",
Variants = variants
};
tu.AddProp("ar", LocalizedStringCache.kDiscoveredDyanmically, "true");
tu.AddProp("en", LocalizedStringCache.kDiscoveredDyanmically, "true");
doc.AddTransUnit(tu);
doc.Save(Path.Combine(folderPath, LocalizationManager.GetTmxFileNameForLanguage(AppId, "fr")));
}
private void WriteGroupPolyglot(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement("group");
writer.WriteAttributeString("id", transUnit.Id);
WriteTransUnitPolytlot(writer, transUnit);
writer.WriteEndElement(); // group
}
private static void AddEnglishTmx(string folderPath, string appVersion)
{
var englishDoc = new TMXDocument {
Header = { SourceLang = "en" }
};
if (!String.IsNullOrEmpty(appVersion))
{
englishDoc.Header.SetPropValue(LocalizationManager.kAppVersionPropTag, appVersion);
}
// first unit
var variants = new List <TransUnitVariant> {
new TransUnitVariant {
Lang = "en", Value = "from English TMX"
}
};
var tu = new TransUnit
{
Id = "theId",
Variants = variants
};
tu.AddProp("en", LocalizedStringCache.kDiscoveredDyanmically, "true");
englishDoc.AddTransUnit(tu);
// second unit
var variants2 = new List <TransUnitVariant> {
new TransUnitVariant {
Lang = "en", Value = "no longer used English text"
}
};
var prop = new TMXProp();
prop.Type = LocalizedStringCache.kNoLongerUsedPropTag;
prop.Value = "true";
var tu2 = new TransUnit
{
Id = "notUsedId",
Variants = variants2,
Props = { prop }
};
englishDoc.AddTransUnit(tu2);
// third unit
var variants3 = new List <TransUnitVariant> {
new TransUnitVariant {
Lang = "en", Value = "blah"
}
};
var tu3 = new TransUnit
{
Id = "blahId",
Variants = variants3
};
englishDoc.AddTransUnit(tu3);
englishDoc.Save(Path.Combine(folderPath, LocalizationManager.GetTmxFileNameForLanguage(AppId, "en")));
}
private void WriteTransUnitPolytlot(XmlWriter writer, TransUnit transUnit)
{
foreach (var segmentPair in transUnit.SegmentPairs)
{
var originType = segmentPair.TranslationOrigin != null ? segmentPair.TranslationOrigin.OriginType : string.Empty;
var originSystem = segmentPair.TranslationOrigin != null ? segmentPair.TranslationOrigin.OriginSystem : string.Empty;
var matchPercentage = segmentPair.TranslationOrigin?.MatchPercent.ToString() ?? "0";
var structMatch = segmentPair.TranslationOrigin?.IsStructureContextMatch.ToString() ?? string.Empty;
var textMatch = segmentPair.TranslationOrigin?.TextContextMatchLevel.ToString();
writer.WriteStartElement("trans-unit");
writer.WriteAttributeString("id", segmentPair.Id);
if (segmentPair.IsLocked)
{
writer.WriteAttributeString(NsPrefix, "locked", null, segmentPair.IsLocked.ToString());
}
if (IncludeTranslations)
{
writer.WriteAttributeString(NsPrefix, "conf", null, segmentPair.ConfirmationLevel.ToString());
writer.WriteAttributeString(NsPrefix, "origin", null, originType);
if (!string.IsNullOrEmpty(originSystem))
{
writer.WriteAttributeString(NsPrefix, "origin-system", null, originSystem);
}
if (!string.IsNullOrEmpty(matchPercentage) && matchPercentage != "0")
{
writer.WriteAttributeString(NsPrefix, "percent", null, matchPercentage);
}
if (!string.IsNullOrEmpty(structMatch) && structMatch != "False")
{
writer.WriteAttributeString(NsPrefix, "struct-match", null, structMatch);
}
if (!string.IsNullOrEmpty(textMatch) && textMatch != "None")
{
writer.WriteAttributeString(NsPrefix, "text-match", null, textMatch);
}
}
WriteSegmentNotesPolyglot(writer, segmentPair);
WriteSegmentPolyglot(writer, segmentPair, true);
if (IncludeTranslations)
{
WriteSegmentPolyglot(writer, segmentPair, false);
}
writer.WriteEndElement(); // trans-unit
}
}
public void DataTest_Xlf_NodeId(string inputFile, int nodeId)
{
/* Initialization. */
Xlf testXlf = new Xlf(inputFile);
/* Set of Assertions. */
TransUnit testTransUnit = testXlf.GetBody.GetTransUnit(nodeId);
Assert.IsNotNull(testTransUnit);
Assert.AreEqual(nodeId + 2, testTransUnit.GetId);
}
public void DataTest_Body_GetTransUnit_Tests_1(string inputFile, int nodeId)
{
/* Initialization. */
Xlf testXlf = new Xlf(inputFile);
TransUnit testTransUnit = testXlf.GetBody.GetTransUnit(nodeId);
/* Set of Assertions. */
Assert.IsNotNull(testTransUnit);
Assert.AreEqual((nodeId + 1).ToString(), testTransUnit.GetId);
}
private void WriteSdlSegDefs(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement(NsPrefix, "seg-defs", null);
foreach (var segmentPair in transUnit.SegmentPairs)
{
WriteSdlSeg(writer, segmentPair);
}
writer.WriteEndElement(); //sdl:seg-defs
}
private void WriteSdlSegCtxs(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement(NsPrefix, "seg-cxts", null);
foreach (var context in transUnit.Contexts)
{
WriteSdlSegCtx(writer, context);
}
writer.WriteEndElement(); //sdl:seg-cxts
}
public void DataTest_Body_GetTransUnit_Tests_2(string inputFile, int nodePosition, string nodeTranslatable)
{
/* Initialization. */
Xlf testXlf = new Xlf(inputFile);
TransUnit testTransUnit = testXlf.GetBody.GetTransUnit(nodePosition);
/* Set of Assertions. */
Assert.IsNotNull(testTransUnit);
Assert.AreEqual(nodeTranslatable, testTransUnit.GetTranslate);
}
private void WriteTransUnit(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement("trans-unit");
writer.WriteAttributeString("id", transUnit.Id);
WriteSourceParagraph(writer, transUnit);
WriteSegSource(writer, transUnit);
WriteTargetParagraph(writer, transUnit);
WriteSdlSegDefs(writer, transUnit);
writer.WriteEndElement(); // trans-unit
}
public Body(XmlNode xmlBody)
{
this.xmlBody = xmlBody;
xmlTransUnitList = xmlBody.SelectNodes("//trans-unit");
transUnitList = new LinkedList <TransUnit>();
TransUnit auxiliaryTransUnit = new TransUnit();
foreach (XmlNode xmlNode in xmlTransUnitList)
{
auxiliaryTransUnit = new TransUnit(xmlNode);
transUnitList.AddLast(auxiliaryTransUnit);
}
}
private static void AddArabicTmx(string folderPath)
{
var arabicDoc = new TMXDocument {
Header = { SourceLang = "ar" }
};
// first unit
var variants = new List <TransUnitVariant>
{
new TransUnitVariant {
Lang = "en", Value = "wrong"
},
new TransUnitVariant {
Lang = "ar", Value = "inArabic"
}
};
var tu = new TransUnit
{
Id = "theId",
Variants = variants
};
tu.AddProp("ar", LocalizedStringCache.kDiscoveredDyanmically, "true");
tu.AddProp("en", LocalizedStringCache.kDiscoveredDyanmically, "true");
arabicDoc.AddTransUnit(tu);
// second unit
var variants2 = new List <TransUnitVariant>
{
new TransUnitVariant {
Lang = "en", Value = "inEnglishpartofArabicTMX"
},
new TransUnitVariant {
Lang = "ar", Value = "inArabic"
}
};
var tu2 = new TransUnit
{
Id = "notUsedId",
Variants = variants2
};
tu2.AddProp("ar", LocalizedStringCache.kDiscoveredDyanmically, "true");
tu2.AddProp("en", LocalizedStringCache.kDiscoveredDyanmically, "true");
// Note: we are NOT adding a NoLongerUsed property to the Arabic TMX
arabicDoc.AddTransUnit(tu2);
arabicDoc.Save(Path.Combine(folderPath, LocalizationManager.GetTmxFileNameForLanguage(AppId, "ar")));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the category for the specified id.
/// </summary>
/// ------------------------------------------------------------------------------------
internal LocalizationCategory GetCategory(string id)
{
TransUnit tu = TmxDocument.GetTransUnitForId(id);
if (tu != null)
{
string category = tu.GetPropValue(kCategoryPropTag);
try
{
return((LocalizationCategory)Enum.Parse(typeof(LocalizationCategory), category));
}
catch { }
}
return(LocalizationCategory.Other);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the priority for the specified id.
/// </summary>
/// ------------------------------------------------------------------------------------
internal LocalizationPriority GetPriority(string id)
{
TransUnit tu = TmxDocument.GetTransUnitForId(id);
if (tu != null)
{
string priority = tu.GetPropValue(kPriorityPropTag);
try
{
return((LocalizationPriority)Enum.Parse(typeof(LocalizationPriority), priority));
}
catch { }
}
return(LocalizationPriority.NotLocalizable);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Updates the value for the specified translation unit with the specified new value.
/// </summary>
/// ------------------------------------------------------------------------------------
private TransUnit UpdateValue(TransUnit tu, string newValue, LocalizingInfo locInfo, string tuId)
{
newValue = newValue ?? string.Empty;
// Get rid of the variant we are about to set if it is present.
// If no variants remain get rid of the whole thing.
// Later we will create whatever we need.
if (tu != null)
{
var tuv = tu.GetVariantForLang(locInfo.LangId);
if (tuv != null)
{
// don't need to update if the value hasn't changed
if (tuv.Value == newValue)
{
return(tu);
}
_updated = true;
tu.RemoveVariant(tuv);
if (tu.Variants.Count == 0)
{
_tmxDoc.RemoveTransUnit(tu);
tu = null; // so we will make a new one if needed.
}
}
}
if (newValue == string.Empty)
{
return(tu);
}
// Create a new entry if needed.
if (tu == null)
{
tu = new TransUnit();
tu.Id = tuId;
_tmxDoc.AddTransUnit(tu);
}
tu.AddOrReplaceVariant(locInfo.LangId, newValue);
_updated = true;
return(tu);
}
private void UpdateContexts(File file, IParagraphUnit paragraphUnit, TransUnit transUnit)
{
if (paragraphUnit.Properties.Contexts?.Contexts != null)
{
foreach (var context in paragraphUnit.Properties.Contexts.Contexts)
{
var existingContext = file.Header.Contexts.FirstOrDefault(a =>
string.Compare(a.ContextType, context.ContextType, StringComparison.CurrentCultureIgnoreCase) == 0 &&
string.Compare(a.DisplayCode, context.DisplayCode, StringComparison.CurrentCultureIgnoreCase) == 0 &&
string.Compare(a.DisplayName, context.DisplayName, StringComparison.CurrentCultureIgnoreCase) == 0 &&
string.Compare(a.Description, context.Description, StringComparison.CurrentCultureIgnoreCase) == 0);
if (existingContext != null)
{
transUnit.Contexts.Add(existingContext);
}
else
{
_contextIndex++;
var newContext = new Context
{
Id = _contextIndex.ToString(),
ContextType = context.ContextType,
Description = context.Description,
DisplayCode = context.DisplayCode,
DisplayName = context.DisplayName
};
if (context.MetaData != null)
{
foreach (var metaData in context.MetaData)
{
newContext.MetaData.Add(metaData.Key, metaData.Value);
}
}
transUnit.Contexts.Add(newContext);
file.Header.Contexts.Add(newContext);
}
}
}
}
private void WriteTargetParagraph(XmlWriter writer, TransUnit transUnit)
{
writer.WriteStartElement("target");
foreach (var segmentPair in transUnit.SegmentPairs)
{
writer.WriteStartElement("mrk");
writer.WriteAttributeString("mtype", "seg");
writer.WriteAttributeString("mid", segmentPair.Id);
foreach (var element in segmentPair.Target.Elements)
{
WriteSegment(writer, element);
}
writer.WriteEndElement(); // mrk
}
writer.WriteEndElement(); // seg-source
}
///// ------------------------------------------------------------------------------------
///// <summary>
///// Saves the cache to the specified file, if the cache is dirty. If the cache is
///// dirty and saved, then true is returned. Otherwise, false is returned.
///// </summary>
///// ------------------------------------------------------------------------------------
//private bool SaveIfDirty(string tmxFile)
//{
// if (!IsDirty || string.IsNullOrEmpty(tmxFile))
// return false;
// //_tmxFile = tmxFile;
// IsDirty = false;
// TmxDocument.Body.TransUnits.Sort(TuComparer);
// TmxDocument.Save(tmxFile);
// return true;
//}
#endregion
/// ------------------------------------------------------------------------------------
/// <summary>
/// Compares two translation units for equality.
/// </summary>
/// ------------------------------------------------------------------------------------
private static int TuComparer(TransUnit tu1, TransUnit tu2)
{
if (tu1 == null && tu2 == null)
{
return(0);
}
if (tu1 == null)
{
return(-1);
}
if (tu2 == null)
{
return(1);
}
string x = tu1.GetPropValue(kGroupPropTag);
string y = tu2.GetPropValue(kGroupPropTag);
if (x == y)
{
return(String.CompareOrdinal(tu1.Id, tu2.Id));
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
return(String.CompareOrdinal(x, y));
}
private bool IsTranslationUnitNoLongerUsed(TransUnit tu)
{
return(_englishTuIdsNoLongerUsed.Contains(tu.Id));
}
public void ProcessParagraphUnit(IParagraphUnit paragraphUnit)
{
if (paragraphUnit.IsStructure || !paragraphUnit.SegmentPairs.Any())
{
return;
}
var transUnit = new TransUnit
{
Id = paragraphUnit.Properties.ParagraphUnitId.Id
};
foreach (var segmentPair in paragraphUnit.SegmentPairs)
{
var segmentPairInfo = SegmentPairProcessor.GetSegmentPairInfo(segmentPair);
var status = segmentPair.Properties.ConfirmationLevel.ToString();
var match = Enumerators.GetTranslationOriginType(segmentPair.Target.Properties.TranslationOrigin, _analysisBands);
if (_exportOptions.ExcludeFilterIds != null)
{
if ((segmentPair.Properties.IsLocked && _exportOptions.ExcludeFilterIds.Exists(a => a == "Locked")) ||
_exportOptions.ExcludeFilterIds.Exists(a => a == status) ||
_exportOptions.ExcludeFilterIds.Exists(a => a == match))
{
AddWordCounts(status, ConfirmationStatistics.WordCounts.Excluded, segmentPairInfo);
AddWordCounts(match, TranslationOriginStatistics.WordCounts.Excluded, segmentPairInfo);
continue;
}
}
SegmentVisitor.VisitSegment(segmentPair.Source);
if (SegmentVisitor.HasRevisions)
{
throw new Exception(PluginResources.Message_UnableToProcessFileWithTrackChanges +
Environment.NewLine +
PluginResources.Message_AccecptRejectTrackChangesBeforeExporting);
}
var sourceElements = SegmentVisitor.Elements;
if (SegmentVisitor.Comments.Count > 0)
{
foreach (var comment in SegmentVisitor.Comments)
{
if (!Xliff.DocInfo.Comments.ContainsKey(comment.Key))
{
Xliff.DocInfo.Comments.Add(comment.Key, comment.Value);
}
}
}
UpdateTagIds();
if (segmentPair.Target?.Count == 0 && _exportOptions.CopySourceToTarget)
{
segmentPair.Target.Clear();
foreach (var sourceElement in segmentPair.Source)
{
segmentPair.Target.Add(sourceElement.Clone() as IAbstractMarkupData);
}
}
SegmentVisitor.VisitSegment(segmentPair.Target);
if (SegmentVisitor.HasRevisions)
{
throw new Exception(PluginResources.Message_UnableToProcessFileWithTrackChanges +
Environment.NewLine +
PluginResources.Message_AccecptRejectTrackChangesBeforeExporting);
}
var targetElements = SegmentVisitor.Elements;
if (SegmentVisitor.Comments.Count > 0)
{
foreach (var comment in SegmentVisitor.Comments)
{
if (!Xliff.DocInfo.Comments.ContainsKey(comment.Key))
{
Xliff.DocInfo.Comments.Add(comment.Key, comment.Value);
}
}
}
UpdateTagIds();
var newSegmentPair = new SegmentPair(_segmentBuilder)
{
Id = segmentPair.Properties.Id.Id,
Source = new Source {
Elements = sourceElements
},
Target = new Target {
Elements = targetElements
},
IsLocked = segmentPair.Properties.IsLocked,
ConfirmationLevel = segmentPair.Properties.ConfirmationLevel,
TranslationOrigin = segmentPair.Properties.TranslationOrigin
};
transUnit.SegmentPairs.Add(newSegmentPair);
AddWordCounts(status, ConfirmationStatistics.WordCounts.Processed, segmentPairInfo);
AddWordCounts(match, TranslationOriginStatistics.WordCounts.Processed, segmentPairInfo);
}
if (transUnit.SegmentPairs.Count > 0)
{
Xliff.Files[Xliff.Files.Count - 1].Body.TransUnits.Add(transUnit);
}
}
private TransUnit ReadTransUnit(XmlReader xmlReader)
{
var transUnit = new TransUnit();
var sourceSegments = new List <Source>();
var targetSegments = new List <Target>();
var segmentPairProperties = new List <ISegmentPairProperties>();
var index = 0;
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
if (index == 0 && string.Compare(xmlReader.Name, "trans-unit", StringComparison.OrdinalIgnoreCase) == 0)
{
index++;
while (xmlReader.MoveToNextAttribute())
{
if (string.Compare(xmlReader.Name, "id", StringComparison.OrdinalIgnoreCase) == 0)
{
transUnit.Id = xmlReader.Value;
}
}
}
if (string.Compare(xmlReader.Name, "seg-source", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
sourceSegments = ReadSourceSegments(xmlReaderSub);
xmlReaderSub.Close();
}
else if (string.Compare(xmlReader.Name, "target", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
targetSegments = ReadTargetSegments(xmlReaderSub);
xmlReaderSub.Close();
}
else if (string.Compare(xmlReader.Name, NsPrefix + ":seg-defs", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
segmentPairProperties = ReadSegmentPairPropertyDefinitions(xmlReaderSub);
xmlReaderSub.Close();
}
break;
}
}
foreach (var sourceSegment in sourceSegments)
{
var segmentPair = new SegmentPair(_segmentBuilder);
segmentPair.Id = sourceSegment.Id;
segmentPair.Source.Elements.AddRange(sourceSegment.Elements);
var targetSegment = targetSegments.FirstOrDefault(a => a.Id.Equals(sourceSegment.Id));
if (targetSegment != null)
{
segmentPair.Target.Elements.AddRange(targetSegment.Elements);
}
var properties = segmentPairProperties.FirstOrDefault(a => a.Id.Id == segmentPair.Id);
if (properties != null)
{
segmentPair.ConfirmationLevel = properties.ConfirmationLevel;
segmentPair.IsLocked = properties.IsLocked;
segmentPair.TranslationOrigin = properties.TranslationOrigin;
}
transUnit.SegmentPairs.Add(segmentPair);
}
return(transUnit);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the group for the specified id.
/// </summary>
/// ------------------------------------------------------------------------------------
internal string GetGroup(string id)
{
TransUnit tu = TmxDocument.GetTransUnitForId(id);
return(tu == null ? null : tu.GetPropValue(kGroupPropTag));
}
