private void WriteSegmentNotesPolyglot(XmlWriter writer, SegmentPair segmentPair)
{
var sourceComments = GetSegmentComments(segmentPair.Source.Elements);
WriteNotes(writer, sourceComments, "source");
if (IncludeTranslations)
{
var targetComments = GetSegmentComments(segmentPair.Target.Elements);
WriteNotes(writer, targetComments, "target");
}
}
private void WriteSegmentPolyglot(XmlWriter writer, SegmentPair segmentPair, bool isSource)
{
writer.WriteStartElement(isSource ? "source" : "target");
var elements = isSource ? segmentPair.Source.Elements : segmentPair.Target.Elements;
foreach (var element in elements)
{
WriteSegment(writer, element);
}
writer.WriteEndElement(); // source or target
}
private void UpdateTargetSegment(ISegmentPair segmentPair, SegmentPair importedSegmentPair, SegmentPairInfo segmentPairInfo)
{
var targetSegment = segmentPair.Target;
var originalSource = (ISegment)segmentPair.Source.Clone();
var originalTarget = (ISegment)targetSegment.Clone();
// clear the existing content from the target segment
targetSegment.Clear();
var containers = new Stack <IAbstractMarkupDataContainer>();
containers.Push(targetSegment);
var lockedContentId = 0;
foreach (var element in importedSegmentPair.Target.Elements)
{
if (element is ElementComment elementComment)
{
UpdateComment(elementComment, containers);
}
if (element is ElementTagPair elementTagPair)
{
UpdateTagPair(elementTagPair, originalTarget, originalSource, containers);
}
if (element is ElementLocked elementLocked)
{
lockedContentId = UpdateLockedContent(elementLocked, lockedContentId, originalTarget, originalSource, containers);
}
if (element is ElementPlaceholder elementPlaceholder)
{
UpdatePlaceholder(elementPlaceholder, originalTarget, originalSource, containers);
}
if (element is ElementGenericPlaceholder genericPlaceholder)
{
UpdateGenericPlaceholder(genericPlaceholder, originalTarget, originalSource, containers);
}
if (element is ElementText elementText && !string.IsNullOrEmpty(elementText.Text))
{
UpdateText(elementText, containers);
}
}
UpdateTranslationOrigin(originalTarget, targetSegment, segmentPairInfo);
}
private void WriteSegmentPolyglot(XmlWriter writer, SegmentPair segmentPair, bool isSource)
{
writer.WriteStartElement(isSource ? "source" : "target");
//writer.WriteAttributeString("xml", "space", null, "preserve");
var elements = isSource ? segmentPair.Source.Elements : segmentPair.Target.Elements;
foreach (var element in elements)
{
WriteSegment(writer, element);
}
writer.WriteEndElement(); // source or target
}
private static string GetTranslationStatus(SegmentPair segmentPair)
{
var match = string.Empty;
if (segmentPair.TranslationOrigin == null)
{
return(match);
}
if (segmentPair.TranslationOrigin.MatchPercentage >= 100)
{
if (string.Compare(segmentPair.TranslationOrigin.OriginType, "document-match", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "PM";
}
else if (string.Compare(segmentPair.TranslationOrigin.TextContextMatchLevel, "SourceAndTarget", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "CM";
}
else if (string.Compare(segmentPair.TranslationOrigin.OriginType, "mt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(segmentPair.TranslationOrigin.OriginType, "nmt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(segmentPair.TranslationOrigin.OriginType, "amt", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "AT";
}
else
{
match = segmentPair.TranslationOrigin.MatchPercentage + "%";
}
}
else if (string.Compare(segmentPair.TranslationOrigin.OriginType, "mt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(segmentPair.TranslationOrigin.OriginType, "nmt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(segmentPair.TranslationOrigin.OriginType, "amt", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "AT";
}
else if (segmentPair.TranslationOrigin.MatchPercentage > 0)
{
match = segmentPair.TranslationOrigin.MatchPercentage + "%";
}
else
{
match = "";
}
return(match);
}
private void RecalcNeighbor([NotNull] SegmentPartWithNeighbor neighbor,
[NotNull] SegmentPartWithNeighbor part,
[NotNull] SegmentPair hulls)
{
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(part.NeighborFeature,
part.NeighborTableIndex);
SegmentHull neighborhull = CreateSegmentHull(
(SegmentProxy)part.NeighborProxy, rowsDistance,
hulls.Neighbor.StartCap, hulls.Neighbor.EndCap);
SegmentHull hull = CreateNeighborSegmentHull(
(SegmentProxy)Assert.NotNull(part.SegmentProxy, "segmentproxy is null"),
rowsDistance, neighbor.NeighborFeature, // == part.Feature
neighbor.NeighborTableIndex, // == part.TableIndex
hulls.Hull.StartCap, hulls.Hull.EndCap);
RecalcPart(neighbor, neighborhull, hull);
}
/// <summary>
/// The route partial.
/// </summary>
/// <param name="content">
/// The content.
/// </param>
/// <param name="segmentContext">
/// The segment context.
/// </param>
/// <returns>
/// The <see cref="object"/>.
/// </returns>
public object RoutePartial(PageData content, SegmentContext segmentContext)
{
if (segmentContext == null)
{
return(content);
}
// Use helper method GetNextValue to get the next part from the URL
SegmentPair nextSegment = segmentContext.GetNextValue(segmentContext.RemainingPath);
string output = nextSegment.Next;
if (string.IsNullOrWhiteSpace(output))
{
return(content);
}
segmentContext.RemainingPath = nextSegment.Remaining;
if (output.Equals(OutputConstants.PDF, StringComparison.OrdinalIgnoreCase) && OutputSettings.Instance.EnablePDF)
{
OutputHelper.HandlePdf(content);
}
if (output.Equals(OutputConstants.Text, StringComparison.OrdinalIgnoreCase) && OutputSettings.Instance.EnableTXT)
{
OutputHelper.HandleTxt(content);
}
if (output.Equals(OutputConstants.XML, StringComparison.OrdinalIgnoreCase) && OutputSettings.Instance.EnableXML)
{
OutputHelper.HandleXml(content);
}
if (output.Equals(OutputConstants.JSON, StringComparison.OrdinalIgnoreCase) && OutputSettings.Instance.EnableJSON)
{
OutputHelper.HandleJson(content);
}
return(content);
}
private static bool ImportTranslation(SegmentPair segmentPair)
{
var importTranslation = true;
if (segmentPair.IsLocked && Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportLocked)
{
importTranslation = false;
}
else if (!segmentPair.IsLocked && Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportUnLocked)
{
importTranslation = false;
}
else if (string.Compare(segmentPair.MatchTypeId, "Perfect Match", StringComparison.OrdinalIgnoreCase) == 0 &&
Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportPerfectMatch)
{
importTranslation = false;
}
else if (string.Compare(segmentPair.MatchTypeId, "Context Match", StringComparison.OrdinalIgnoreCase) == 0 &&
Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportContextMatch)
{
importTranslation = false;
}
else if (string.Compare(segmentPair.MatchTypeId, "Exact Match", StringComparison.OrdinalIgnoreCase) == 0 &&
Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportExactMatch)
{
importTranslation = false;
}
else if (string.Compare(segmentPair.MatchTypeId, "Fuzzy Match", StringComparison.OrdinalIgnoreCase) == 0 &&
Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportFuzzyMatch)
{
importTranslation = false;
}
else if (string.Compare(segmentPair.MatchTypeId, "No Match", StringComparison.OrdinalIgnoreCase) == 0 &&
Sdl.Community.XliffReadWrite.Processor.ProcessorSettings.DoNotImportNoMatch)
{
importTranslation = false;
}
return(importTranslation);
}
private SegmentPair ReadTransUnit(XmlReader xmlReader)
{
var segmentPair = new SegmentPair(_segmentBuilder);
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)
{
// for polyglot support, the segment id is represented by the trans-unit id
segmentPair.Id = xmlReader.Value;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":conf", StringComparison.OrdinalIgnoreCase) == 0)
{
var success = Enum.TryParse <ConfirmationLevel>(xmlReader.Value, true, out var value);
segmentPair.ConfirmationLevel = success ? value : ConfirmationLevel.Unspecified;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":locked", StringComparison.OrdinalIgnoreCase) == 0)
{
var success = bool.TryParse(xmlReader.Value, out var result);
segmentPair.IsLocked = success && result;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":origin", StringComparison.OrdinalIgnoreCase) == 0)
{
segmentPair.TranslationOrigin.OriginType = xmlReader.Value;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":origin-system", StringComparison.OrdinalIgnoreCase) == 0)
{
segmentPair.TranslationOrigin.OriginSystem = xmlReader.Value;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":percent", StringComparison.OrdinalIgnoreCase) == 0)
{
var success = byte.TryParse(xmlReader.Value, out var result);
segmentPair.TranslationOrigin.MatchPercent = success ? result : (byte)0;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":struct-match", StringComparison.OrdinalIgnoreCase) == 0)
{
var success = bool.TryParse(xmlReader.Value, out var result);
segmentPair.TranslationOrigin.IsStructureContextMatch = success && result;
}
if (string.Compare(xmlReader.Name, NsPrefix + ":text-match", StringComparison.OrdinalIgnoreCase) == 0)
{
var success = Enum.TryParse <TextContextMatchLevel>(xmlReader.Value, true, out var result);
segmentPair.TranslationOrigin.TextContextMatchLevel = success ? result : TextContextMatchLevel.None;
}
}
}
else if (string.Compare(xmlReader.Name, "source", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
segmentPair.Source = ReadSource(xmlReaderSub);
xmlReaderSub.Close();
}
else if (string.Compare(xmlReader.Name, "target", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
segmentPair.Target = ReadTarget(xmlReaderSub);
xmlReaderSub.Close();
}
else if (string.Compare(xmlReader.Name, "note", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
var comment = ReadComment(xmlReaderSub, out var id);
AddCommentToCollection(id, comment);
xmlReaderSub.Close();
}
break;
}
}
return(segmentPair);
}
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 void UpdateTranslationOrigin(ISegment originalTarget, ISegment targetSegment, SegmentPairInfo segmentPairInfo, SegmentPair importedSegmentPair)
{
SegmentVisitor.VisitSegment(originalTarget);
var originalText = SegmentVisitor.Text;
SegmentVisitor.VisitSegment(targetSegment);
var updatedText = SegmentVisitor.Text;
if (string.Compare(originalText, updatedText, StringComparison.Ordinal) != 0)
{
if (!string.IsNullOrEmpty(_importOptions.StatusTranslationUpdatedId))
{
if (targetSegment.Properties.TranslationOrigin == null)
{
targetSegment.Properties.TranslationOrigin = importedSegmentPair.TranslationOrigin;
}
if (targetSegment.Properties.TranslationOrigin != null)
{
var currentTranslationOrigin = (ITranslationOrigin)targetSegment.Properties.TranslationOrigin.Clone();
targetSegment.Properties.TranslationOrigin.OriginBeforeAdaptation = currentTranslationOrigin;
}
else
{
targetSegment.Properties.TranslationOrigin = _segmentBuilder.CreateTranslationOrigin();
}
SetTranslationOrigin(targetSegment);
var success = Enum.TryParse <ConfirmationLevel>(_importOptions.StatusTranslationUpdatedId, true, out var result);
var statusTranslationUpdated = success ? result : importedSegmentPair.ConfirmationLevel;
targetSegment.Properties.ConfirmationLevel = statusTranslationUpdated;
targetSegment.Properties.IsLocked = importedSegmentPair.IsLocked;
}
else
{
targetSegment.Properties.TranslationOrigin = importedSegmentPair.TranslationOrigin;
targetSegment.Properties.IsLocked = importedSegmentPair.IsLocked;
targetSegment.Properties.ConfirmationLevel = importedSegmentPair.ConfirmationLevel;
}
var status = targetSegment.Properties.ConfirmationLevel.ToString();
var match = Enumerators.GetTranslationOriginType(targetSegment.Properties.TranslationOrigin, _analysisBands);
AddWordCounts(status, segmentPairInfo, match);
}
else
{
if (!string.IsNullOrEmpty(_importOptions.StatusTranslationNotUpdatedId))
{
var success = Enum.TryParse <ConfirmationLevel>(_importOptions.StatusTranslationNotUpdatedId, true, out var result);
var statusTranslationNotUpdated = success ? result : importedSegmentPair.ConfirmationLevel;
targetSegment.Properties.ConfirmationLevel = statusTranslationNotUpdated;
}
else
{
targetSegment.Properties.ConfirmationLevel = importedSegmentPair.ConfirmationLevel;
}
targetSegment.Properties.TranslationOrigin = importedSegmentPair.TranslationOrigin;
targetSegment.Properties.IsLocked = importedSegmentPair.IsLocked;
var status = targetSegment.Properties.ConfirmationLevel.ToString();
var match = Enumerators.GetTranslationOriginType(targetSegment.Properties.TranslationOrigin, _analysisBands);
AddWordCounts(status, segmentPairInfo, match);
}
}
private void UpdateTargetSegment(ISegmentPair segmentPair, SegmentPair importedSegmentPair, SegmentPairInfo segmentPairInfo)
{
var sourceSegment = segmentPair.Source;
var targetSegment = segmentPair.Target;
var originalSource = (ISegment)sourceSegment.Clone();
var originalTarget = (ISegment)targetSegment.Clone();
if (_importBackTranslations &&
importedSegmentPair.TranslationOrigin != null &&
importedSegmentPair.TranslationOrigin.MetaDataContainsKey("back-translation"))
{
var backTranslation = importedSegmentPair.TranslationOrigin.GetMetaData("back-translation");
var backTranslationTokens = JsonConvert.DeserializeObject <List <Token> >(backTranslation);
targetSegment = _segmentBuilder.GetUpdatedSegment(targetSegment,
backTranslationTokens, sourceSegment);
}
else
{
// clear the existing content from the target segment
targetSegment.Clear();
var containers = new Stack <IAbstractMarkupDataContainer>();
containers.Push(targetSegment);
var lockedContentId = 0;
foreach (var element in importedSegmentPair.Target.Elements)
{
if (element is ElementComment elementComment)
{
UpdateComment(elementComment, containers);
}
if (element is ElementTagPair elementTagPair)
{
UpdateTagPair(elementTagPair, originalTarget, originalSource, containers);
}
if (element is ElementLocked elementLocked)
{
lockedContentId = UpdateLockedContent(elementLocked, lockedContentId, originalTarget,
originalSource, containers);
}
if (element is ElementPlaceholder elementPlaceholder)
{
UpdatePlaceholder(elementPlaceholder, originalTarget, originalSource, containers);
}
if (element is ElementGenericPlaceholder genericPlaceholder)
{
UpdateGenericPlaceholder(genericPlaceholder, originalTarget, originalSource, containers);
}
if (element is ElementText elementText && !string.IsNullOrEmpty(elementText.Text))
{
UpdateText(elementText, containers);
}
}
}
UpdateTranslationOrigin(originalTarget, targetSegment, segmentPairInfo, importedSegmentPair);
}
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);
}
private void AddToComparision(ref ComparisonParagraphUnit comparisonParagraphUnit
, ComparisonSegmentUnit comparisonSegmentUnit
, SegmentPair segmentPairOriginal
, SegmentPair segmentPairUpdated)
{
comparisonSegmentUnit.SegmentStatusOriginal = segmentPairOriginal.SegmentStatus;
comparisonSegmentUnit.SegmentStatusUpdated = segmentPairUpdated.SegmentStatus;
comparisonSegmentUnit.TranslationStatusOriginal = GetTranslationStatus(segmentPairOriginal);
comparisonSegmentUnit.TranslationStatusUpdated = GetTranslationStatus(segmentPairUpdated);
if (segmentPairOriginal.TranslationOrigin != null)
{
comparisonSegmentUnit.TranslationOriginTypeOriginal = segmentPairOriginal.TranslationOrigin.OriginType;
}
if (segmentPairUpdated.TranslationOrigin != null)
{
comparisonSegmentUnit.TranslationOriginTypeUpdated = segmentPairUpdated.TranslationOrigin.OriginType;
}
comparisonSegmentUnit.TranslationSectionsWordsIdentical = 0;
comparisonSegmentUnit.TranslationSectionsCharactersIdentical = 0;
comparisonSegmentUnit.TranslationSectionsTagsIdentical = 0;
comparisonSegmentUnit.TranslationSectionsWordsNew = 0;
comparisonSegmentUnit.TranslationSectionsCharactersNew = 0;
comparisonSegmentUnit.TranslationSectionsTagsNew = 0;
comparisonSegmentUnit.TranslationSectionsWordsRemoved = 0;
comparisonSegmentUnit.TranslationSectionsCharactersRemoved = 0;
comparisonSegmentUnit.TranslationSectionsTagsRemoved = 0;
comparisonSegmentUnit.TranslationSectionsWords = 0;
comparisonSegmentUnit.TranslationSectionsCharacters = 0;
comparisonSegmentUnit.TranslationSectionsTags = 0;
comparisonSegmentUnit.TranslationSectionsChangedWords = 0;
comparisonSegmentUnit.TranslationSectionsChangedCharacters = 0;
comparisonSegmentUnit.TranslationSectionsChangedTags = 0;
if (string.Compare(segmentPairOriginal.Target, segmentPairUpdated.Target, StringComparison.OrdinalIgnoreCase) != 0)
{
try
{
comparisonSegmentUnit.ComparisonTextUnits = GetComparisonTextUnits(segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections);
foreach (var comparisonTextUnit in comparisonSegmentUnit.ComparisonTextUnits)
{
switch (comparisonTextUnit.ComparisonTextUnitType)
{
case ComparisonTextUnitType.Identical:
foreach (var segmentSection in comparisonTextUnit.TextSections)
{
if (segmentSection.Content.Trim() != string.Empty)
{
if (segmentSection.IsText)
{
comparisonSegmentUnit.TranslationSectionsWordsIdentical++;
}
else
{
comparisonSegmentUnit.TranslationSectionsTagsIdentical++;
}
}
if (segmentSection.IsText)
{
comparisonSegmentUnit.TranslationSectionsCharactersIdentical += segmentSection.Content.ToCharArray().Length;
}
}
break;
case ComparisonTextUnitType.New:
foreach (var segmentSection in comparisonTextUnit.TextSections)
{
if (segmentSection.Content.Trim() != string.Empty)
{
if (segmentSection.IsText)
{
comparisonSegmentUnit.TranslationSectionsWordsNew++;
}
else
{
comparisonSegmentUnit.TranslationSectionsTagsNew++;
}
}
if (segmentSection.IsText)
{
comparisonSegmentUnit.TranslationSectionsCharactersNew += segmentSection.Content.ToCharArray().Length;
}
}
break;
case ComparisonTextUnitType.Removed:
foreach (var segmentSection in comparisonTextUnit.TextSections)
{
if (segmentSection.Content.Trim() != string.Empty)
{
if (segmentSection.IsText)
{
comparisonSegmentUnit.TranslationSectionsWordsRemoved++;
}
else
{
comparisonSegmentUnit.TranslationSectionsTagsRemoved++;
}
}
if (segmentSection.IsText)
{
comparisonSegmentUnit.TranslationSectionsCharactersRemoved += segmentSection.Content.ToCharArray().Length;
}
}
break;
}
}
comparisonSegmentUnit.TranslationSectionsWords = comparisonSegmentUnit.TranslationSectionsWordsIdentical + comparisonSegmentUnit.TranslationSectionsWordsRemoved;
comparisonSegmentUnit.TranslationSectionsCharacters = comparisonSegmentUnit.TranslationSectionsCharactersIdentical + comparisonSegmentUnit.TranslationSectionsCharactersRemoved;
comparisonSegmentUnit.TranslationSectionsTags = comparisonSegmentUnit.TranslationSectionsTagsIdentical + comparisonSegmentUnit.TranslationSectionsTagsRemoved;
var totalChangesWords = comparisonSegmentUnit.TranslationSectionsWordsNew + comparisonSegmentUnit.TranslationSectionsWordsRemoved;
var totalChangesCharacters = comparisonSegmentUnit.TranslationSectionsCharactersNew + comparisonSegmentUnit.TranslationSectionsCharactersRemoved;
var totalChangesTags = comparisonSegmentUnit.TranslationSectionsTagsNew + comparisonSegmentUnit.TranslationSectionsTagsRemoved;
comparisonSegmentUnit.TranslationSectionsChangedWords = totalChangesWords;
comparisonSegmentUnit.TranslationSectionsChangedCharacters = totalChangesCharacters;
comparisonSegmentUnit.TranslationSectionsChangedTags = totalChangesTags;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
comparisonSegmentUnit.SegmentTextUpdated = true;
comparisonParagraphUnit.ParagraphIsUpdated = true;
}
if (string.Compare(comparisonSegmentUnit.SegmentStatusOriginal, comparisonSegmentUnit.SegmentStatusUpdated, StringComparison.OrdinalIgnoreCase) != 0)
{
comparisonSegmentUnit.SegmentSegmentStatusUpdated = true;
comparisonParagraphUnit.ParagraphStatusChanged = true;
}
if (segmentPairUpdated.Comments != null && segmentPairUpdated.Comments.Count > 0)
{
comparisonSegmentUnit.Comments = segmentPairUpdated.Comments;
comparisonSegmentUnit.SegmentHasComments = true;
comparisonParagraphUnit.ParagraphHasComments = true;
}
comparisonParagraphUnit.ComparisonSegmentUnits.Add(comparisonSegmentUnit);
}
internal Dictionary <string, Dictionary <string, ComparisonParagraphUnit> > GetComparisonParagraphUnits(Dictionary <string, Dictionary <string, ParagraphUnit> > fileParagraphUnitsOriginal
, Dictionary <string, Dictionary <string, ParagraphUnit> > fileParagraphUnitsUpdated)
{
var comparisonFileParagraphUnits = new Dictionary <string, Dictionary <string, ComparisonParagraphUnit> >();
var iProgressCurrent = 0;
var iProgressMaximum = fileParagraphUnitsOriginal.Sum(fileParagraphUnits => fileParagraphUnits.Value.Count);
foreach (var fileParagraphUnitOriginal in fileParagraphUnitsOriginal)
{
var comparisonParagraphUnits = new Dictionary <string, ComparisonParagraphUnit>();
if (!fileParagraphUnitsUpdated.ContainsKey(fileParagraphUnitOriginal.Key))
{
throw new Exception("Error: Structure mismatch; unable to locate the corresponding file : '"
+ fileParagraphUnitOriginal.Key + "' in the updated file");
}
var fileParagraphUnitUdpated = fileParagraphUnitsUpdated[fileParagraphUnitOriginal.Key];
foreach (var xParagraphUnitOriginalPair in fileParagraphUnitOriginal.Value)
{
OnProgress(iProgressMaximum, iProgressCurrent++, "");
var comparisonParagraphUnit = new ComparisonParagraphUnit
{
ParagraphId = xParagraphUnitOriginalPair.Key,
ParagraphIsUpdated = false,
ParagraphStatusChanged = false,
ParagraphHasComments = false
};
var paragraphUnitOriginal = xParagraphUnitOriginalPair.Value;
ParagraphUnit paragraphUnitUpdated;
if (fileParagraphUnitUdpated.ContainsKey(paragraphUnitOriginal.ParagraphUnitId))
{
paragraphUnitUpdated = fileParagraphUnitUdpated[paragraphUnitOriginal.ParagraphUnitId];
}
else
{
throw new Exception("Error: Structure mismatch; unable to locate the corresponding paragraph ID: '"
+ paragraphUnitOriginal.ParagraphUnitId + "' in the updated file");
}
if (paragraphUnitOriginal.SegmentPairs.Count >= paragraphUnitUpdated.SegmentPairs.Count)
{
//if segment count has not changed (or greater than the segment count in the updated file)
for (var i = 0; i < paragraphUnitOriginal.SegmentPairs.Count; i++)
{
var segmentPairOriginal = paragraphUnitOriginal.SegmentPairs[i];
var segmentPairUpdated = new SegmentPair();
if (paragraphUnitUpdated.SegmentPairs.Count > i)
{
segmentPairUpdated = paragraphUnitUpdated.SegmentPairs[i];
}
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairOriginal.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
}
else if (paragraphUnitOriginal.SegmentPairs.Count < paragraphUnitUpdated.SegmentPairs.Count)
{
//if more segments now exist in the updated file
for (var i = 0; i < paragraphUnitUpdated.SegmentPairs.Count; i++)
{
var segmentPairOriginal = new SegmentPair();
if (paragraphUnitOriginal.SegmentPairs.Count > i)
{
segmentPairOriginal = paragraphUnitOriginal.SegmentPairs[i];
}
var segmentPairUpdated = paragraphUnitUpdated.SegmentPairs[i];
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairUpdated.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
}
comparisonParagraphUnits.Add(comparisonParagraphUnit.ParagraphId, comparisonParagraphUnit);
}
comparisonFileParagraphUnits.Add(fileParagraphUnitOriginal.Key, comparisonParagraphUnits);
}
return(comparisonFileParagraphUnits);
}
internal Dictionary <string, Dictionary <string, ComparisonParagraphUnit> > GetComparisonParagraphUnits(Dictionary <string, Dictionary <string, ParagraphUnit> > xFileParagraphUnitsOriginal
, Dictionary <string, Dictionary <string, ParagraphUnit> > xFileParagraphUnitsUpdated)
{
var comparisonFileParagraphUnits = new Dictionary <string, Dictionary <string, ComparisonParagraphUnit> >();
var iProgressCurrent = 0;
var iProgressMaximum = xFileParagraphUnitsOriginal.Sum(xFileParagraphUnits => xFileParagraphUnits.Value.Count());
var errorMatchingFileLevel01 = false;
var errorMatchingFileLevel = false;
var errorMatchingFileLevelMessage = string.Empty;
var errorMatchingParagraphLevel = false;
#region | check for initial errors |
foreach (var fileParagraphUnitOriginal in xFileParagraphUnitsOriginal)
{
if (!xFileParagraphUnitsUpdated.ContainsKey(fileParagraphUnitOriginal.Key))
{
errorMatchingFileLevel = true;
errorMatchingFileLevelMessage =
string.Format(
"Error: Structure mismatch; unable to locate the corresponding file : '{0}' in the updated file",
fileParagraphUnitOriginal.Key);
var fileNameOriginal = Path.GetFileName(fileParagraphUnitOriginal.Key);
errorMatchingFileLevel01 = xFileParagraphUnitsUpdated.Select(kvp => Path.GetFileName(kvp.Key)).All(fileNameUpdated => string.Compare(fileNameOriginal, fileNameUpdated, StringComparison.OrdinalIgnoreCase) != 0);
break;
}
var fileParagraphUnitUpdated = xFileParagraphUnitsUpdated[fileParagraphUnitOriginal.Key];
if ((from paragraphUnitOriginalPair in fileParagraphUnitOriginal.Value
select paragraphUnitOriginalPair.Value into paragraphUnitOriginal
let paragraphUnitUpdated = new ParagraphUnit(paragraphUnitOriginal.ParagraphUnitId, new List <SegmentPair>())
select paragraphUnitOriginal).Any(paragraphUnitOriginal => !fileParagraphUnitUpdated.ContainsKey(paragraphUnitOriginal.ParagraphUnitId)))
{
errorMatchingParagraphLevel = true;
}
}
#endregion
if (errorMatchingFileLevel01)
{
//not possible to compare these files; excluding the file path information, the file names are different...
throw new Exception(errorMatchingFileLevelMessage);
}
if (errorMatchingFileLevel || errorMatchingParagraphLevel)
{
#region | compare structure missmatch |
foreach (var fileParagraphUnitOriginal in xFileParagraphUnitsOriginal)
{
var fileName = Path.GetFileName(fileParagraphUnitOriginal.Key);
var comparisonParagraphUnits = new Dictionary <string, ComparisonParagraphUnit>();
var fileParagraphUnitOriginalTmp = fileParagraphUnitOriginal.Value;
var nameOriginal = Path.GetFileName(fileParagraphUnitOriginal.Key);
var fileParagraphUnitUpdated = (from kvp in xFileParagraphUnitsUpdated let fileNameUpdated = Path.GetFileName(kvp.Key)
where string.Compare(nameOriginal, fileNameUpdated, StringComparison.OrdinalIgnoreCase) == 0
select kvp.Value).FirstOrDefault();
if (fileParagraphUnitUpdated == null)
{
throw new Exception(
string.Format(
"Error: Structure mismatch; unable to locate the corresponding file : '{0}' in the updated file",
fileParagraphUnitOriginal.Key));
}
//update paragraph ids in the updated object xFileParagraphUnit_updated
fileParagraphUnitUpdated = GetUpdatedParagraphsIds(fileParagraphUnitOriginalTmp, fileParagraphUnitUpdated);
foreach (var paragraphUnitOriginalPair in fileParagraphUnitOriginalTmp)
{
OnProgress(iProgressMaximum, iProgressCurrent++, fileName);
var comparisonParagraphUnit = new ComparisonParagraphUnit
{
ParagraphId = paragraphUnitOriginalPair.Key,
ParagraphIsUpdated = false,
ParagraphStatusChanged = false,
ParagraphHasComments = false
};
var paragraphUnitOriginal = paragraphUnitOriginalPair.Value;
var paragraphUnitUpdated = new ParagraphUnit(paragraphUnitOriginal.ParagraphUnitId, new List <SegmentPair>());
if (fileParagraphUnitUpdated.ContainsKey(paragraphUnitOriginal.ParagraphUnitId))
{
paragraphUnitUpdated = fileParagraphUnitUpdated[paragraphUnitOriginal.ParagraphUnitId];
}
if (paragraphUnitUpdated != null)
{
if (paragraphUnitOriginal.SegmentPairs.Count >= paragraphUnitUpdated.SegmentPairs.Count)
{
#region | xParagraphUnit_original.xSegmentPairs.Count >= xParagraphUnit_updated.xSegmentPairs.Count |
//if segment count has not changed (or greater than the segment count in the updated file)
for (var i = 0; i < paragraphUnitOriginal.SegmentPairs.Count; i++)
{
var segmentPairOriginal = paragraphUnitOriginal.SegmentPairs[i];
var segmentPairUpdated = new SegmentPair();
if (paragraphUnitUpdated.SegmentPairs.Count > i)
{
segmentPairUpdated = paragraphUnitUpdated.SegmentPairs[i];
}
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairOriginal.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections, segmentPairOriginal.IsLocked);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
#endregion
}
else if (paragraphUnitOriginal.SegmentPairs.Count < paragraphUnitUpdated.SegmentPairs.Count)
{
#region | xParagraphUnit_original.xSegmentPairs.Count < xParagraphUnit_updated.xSegmentPairs.Count |
//if more segments now exist in the updated file
for (var i = 0; i < paragraphUnitUpdated.SegmentPairs.Count; i++)
{
var segmentPairOriginal = new SegmentPair();
if (paragraphUnitOriginal.SegmentPairs.Count > i)
{
segmentPairOriginal = paragraphUnitOriginal.SegmentPairs[i];
}
var segmentPairUpdated = paragraphUnitUpdated.SegmentPairs[i];
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairUpdated.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections, segmentPairOriginal.IsLocked);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
#endregion
}
}
else
{
#region | else |
foreach (var segmentPairOriginal in paragraphUnitOriginal.SegmentPairs)
{
var segmentPairUpdated = new SegmentPair();
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairOriginal.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections, segmentPairOriginal.IsLocked);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
#endregion
}
comparisonParagraphUnits.Add(comparisonParagraphUnit.ParagraphId, comparisonParagraphUnit);
}
comparisonFileParagraphUnits.Add(fileParagraphUnitOriginal.Key, comparisonParagraphUnits);
}
#endregion
}
else
{
#region | compare normal |
foreach (var fileParagraphUnitOriginal in xFileParagraphUnitsOriginal)
{
var fileName = Path.GetFileName(fileParagraphUnitOriginal.Key);
var comparisonParagraphUnits = new Dictionary <string, ComparisonParagraphUnit>();
if (!xFileParagraphUnitsUpdated.ContainsKey(fileParagraphUnitOriginal.Key))
{
throw new Exception(
string.Format(
"Error: Structure mismatch; unable to locate the corresponding file : '{0}' in the updated file",
fileParagraphUnitOriginal.Key));
}
var fileParagraphUnitUpdated = xFileParagraphUnitsUpdated[fileParagraphUnitOriginal.Key];
foreach (var paragraphUnitOriginalPair in fileParagraphUnitOriginal.Value)
{
OnProgress(iProgressMaximum, iProgressCurrent++, fileName);
var comparisonParagraphUnit = new ComparisonParagraphUnit
{
ParagraphId = paragraphUnitOriginalPair.Key,
ParagraphIsUpdated = false,
ParagraphStatusChanged = false,
ParagraphHasComments = false
};
var paragraphUnitOriginal = paragraphUnitOriginalPair.Value;
ParagraphUnit paragraphUnitUpdated;
if (fileParagraphUnitUpdated.ContainsKey(paragraphUnitOriginal.ParagraphUnitId))
{
paragraphUnitUpdated = fileParagraphUnitUpdated[paragraphUnitOriginal.ParagraphUnitId];
}
else
{
throw new Exception(
string.Format(
"Error: Structure mismatch; unable to locate the corresponding paragraph ID: '{0}' in the updated file",
paragraphUnitOriginal.ParagraphUnitId));
}
if (paragraphUnitOriginal.SegmentPairs.Count >= paragraphUnitUpdated.SegmentPairs.Count)
{
#region | xParagraphUnit_original.xSegmentPairs.Count >= xParagraphUnit_updated.xSegmentPairs.Count |
//if segment count has not changed (or greater than the segment count in the updated file)
for (var i = 0; i < paragraphUnitOriginal.SegmentPairs.Count; i++)
{
var segmentPairOriginal = paragraphUnitOriginal.SegmentPairs[i];
var segmentPairUpdated = new SegmentPair();
if (paragraphUnitUpdated.SegmentPairs.Count > i)
{
segmentPairUpdated = paragraphUnitUpdated.SegmentPairs[i];
}
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairOriginal.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections, segmentPairOriginal.IsLocked);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
#endregion
}
else if (paragraphUnitOriginal.SegmentPairs.Count < paragraphUnitUpdated.SegmentPairs.Count)
{
#region | xParagraphUnit_original.xSegmentPairs.Count < xParagraphUnit_updated.xSegmentPairs.Count |
//if more segments now exist in the updated file
for (var i = 0; i < paragraphUnitUpdated.SegmentPairs.Count; i++)
{
var segmentPairOriginal = new SegmentPair();
if (paragraphUnitOriginal.SegmentPairs.Count > i)
{
segmentPairOriginal = paragraphUnitOriginal.SegmentPairs[i];
}
var segmentPairUpdated = paragraphUnitUpdated.SegmentPairs[i];
var comparisonSegmentUnit = new ComparisonSegmentUnit(segmentPairUpdated.Id, segmentPairOriginal.SourceSections, segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections, segmentPairOriginal.IsLocked);
AddToComparision(ref comparisonParagraphUnit, comparisonSegmentUnit, segmentPairOriginal, segmentPairUpdated);
}
#endregion
}
comparisonParagraphUnits.Add(comparisonParagraphUnit.ParagraphId, comparisonParagraphUnit);
}
comparisonFileParagraphUnits.Add(fileParagraphUnitOriginal.Key, comparisonParagraphUnits);
}
#endregion
}
return(comparisonFileParagraphUnits);
}
private void AddToComparision(ref ComparisonParagraphUnit comparisonParagraphUnit
, ComparisonSegmentUnit comparisonSegmentUnit
, SegmentPair segmentPairOriginal
, SegmentPair segmentPairUpdated)
{
comparisonSegmentUnit.SegmentStatusOriginal = segmentPairOriginal.SegmentStatus;
comparisonSegmentUnit.SegmentStatusUpdated = segmentPairUpdated.SegmentStatus;
comparisonSegmentUnit.TranslationStatusOriginal = GetTranslationStatus(segmentPairOriginal);
comparisonSegmentUnit.TranslationStatusUpdated = GetTranslationStatus(segmentPairUpdated);
if (segmentPairOriginal.TranslationOrigin != null)
{
comparisonSegmentUnit.TranslationOriginTypeOriginal = segmentPairOriginal.TranslationOrigin.OriginType;
}
if (segmentPairUpdated.TranslationOrigin != null)
{
comparisonSegmentUnit.TranslationOriginTypeUpdated = segmentPairUpdated.TranslationOrigin.OriginType;
}
if (string.CompareOrdinal(segmentPairOriginal.Target, segmentPairUpdated.Target) != 0)
{
comparisonSegmentUnit.ComparisonTextUnits = GetComparisonTextUnits(segmentPairOriginal.TargetSections, segmentPairUpdated.TargetSections);
comparisonSegmentUnit.SegmentTextUpdated = true;
comparisonParagraphUnit.ParagraphIsUpdated = true;
}
comparisonSegmentUnit.SourceWordsOriginal = segmentPairOriginal.SourceWords;
comparisonSegmentUnit.SourceCharsOriginal = segmentPairOriginal.SourceChars;
comparisonSegmentUnit.SourceTagsOriginal = segmentPairOriginal.SourceTags;
comparisonSegmentUnit.SourceWordsUpdated = segmentPairUpdated.SourceWords;
comparisonSegmentUnit.SourceCharsUpdated = segmentPairUpdated.SourceChars;
comparisonSegmentUnit.SourceTagsUpdated = segmentPairUpdated.SourceTags;
if (string.Compare(comparisonSegmentUnit.SegmentStatusOriginal, comparisonSegmentUnit.SegmentStatusUpdated, StringComparison.OrdinalIgnoreCase) != 0)
{
comparisonSegmentUnit.SegmentSegmentStatusUpdated = true;
comparisonParagraphUnit.ParagraphStatusChanged = true;
}
if (segmentPairUpdated.Comments != null && segmentPairUpdated.Comments.Count > 0)
{
comparisonSegmentUnit.Comments = segmentPairUpdated.Comments;
comparisonSegmentUnit.SegmentHasComments = true;
comparisonParagraphUnit.ParagraphHasComments = true;
}
comparisonSegmentUnit.TargetOriginalRevisionMarkers = new List <SegmentSection>();
foreach (var section in segmentPairOriginal.TargetSections)
{
if (section.RevisionMarker != null)
{
comparisonSegmentUnit.TargetOriginalRevisionMarkers.Add(section);
}
}
comparisonSegmentUnit.TargetUpdatedRevisionMarkers = new List <SegmentSection>();
foreach (var section in segmentPairUpdated.TargetSections)
{
if (section.RevisionMarker != null)
{
comparisonSegmentUnit.TargetUpdatedRevisionMarkers.Add(section);
}
}
comparisonParagraphUnit.ComparisonSegmentUnits.Add(comparisonSegmentUnit);
}
private static SegmentPair GetBackTranslationSegmentPair(File backTranslationDataFile, SegmentPair segmentPair)
{
if (backTranslationDataFile?.Body == null)
{
return(null);
}
foreach (var transUnit in backTranslationDataFile.Body.TransUnits)
{
foreach (var pair in transUnit.SegmentPairs)
{
if (pair.Id == segmentPair.Id)
{
return(pair);
}
}
}
return(null);
}
private SegmentPair RecalcFlatEnd(
[NotNull] FeaturePoint end,
[NotNull] SegmentPartWithNeighbor segWithNb,
[NotNull] Dictionary <FeaturePoint, SegmentInfo> flatEnds,
out bool neighborIsFlatEnd)
{
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(end.Feature, end.TableIndex);
SegmentInfo segmentInfo;
Find(end, segWithNb.SegmentIndex, flatEnds, out segmentInfo);
SegmentCap startCap = segmentInfo.FlatStart
? (SegmentCap) new RectCap(0)
: new RoundCap();
SegmentCap endCap = segmentInfo.FlatEnd
? (SegmentCap) new RectCap(0)
: new RoundCap();
SegmentHull hull = CreateSegmentHull(
(SegmentProxy)Assert.NotNull(segWithNb.SegmentProxy, "segmentproxy is null"),
rowsDistance, startCap, endCap);
var neighborKey = new FeaturePoint(segWithNb.NeighborFeature,
segWithNb.NeighborTableIndex,
segWithNb.PartIndex, 0);
neighborIsFlatEnd = false;
SegmentInfo neighborInfo;
SegmentCap nbStartCap;
SegmentCap nbEndCap;
if (Find(neighborKey, segWithNb.NeighborProxy.SegmentIndex, flatEnds,
out neighborInfo))
{
neighborIsFlatEnd = true;
nbStartCap = neighborInfo.FlatStart
? (SegmentCap) new RectCap(0)
: new RoundCap();
nbEndCap = neighborInfo.FlatEnd
? (SegmentCap) new RectCap(0)
: new RoundCap();
}
else
{
nbStartCap = new RoundCap();
nbEndCap = new RoundCap();
}
SegmentHull neighborhull = CreateNeighborSegmentHull(
(SegmentProxy)segWithNb.NeighborProxy, rowsDistance, segWithNb.NeighborFeature,
segWithNb.NeighborTableIndex, nbStartCap, nbEndCap);
SegmentPair segPair = RecalcPart(segWithNb, hull, neighborhull);
return(segPair);
}
internal Dictionary <string, ParagraphUnit> ReadRtf(string rtfFile)
{
var rtb = new RichTextBox
{
Enabled = false,
LanguageOption = RichTextBoxLanguageOptions.AutoFont,
ReadOnly = true,
Visible = false,
WordWrap = false,
ShowSelectionMargin = false
};
rtb.SendToBack();
rtb.SuspendLayout();
rtb.LoadFile(rtfFile, RichTextBoxStreamType.RichText);
rtb.Rtf = rtb.Rtf.Replace("\\v\\", "\\v0\\");
rtb.AppendText("\n");
var indexProcessingCurrent = 0;
OnProgress(1000, indexProcessingCurrent, "Initialzing...");
var paragraphUnits = new Dictionary <string, ParagraphUnit>();
var file = rtfFile;
var fileAttributes = new FileAttributes();
var iTagId = 10000;
var innerFileName = string.Empty;
var regexFile = new Regex(@"\<file source\=""(?<x1>[^""]*)""\s+target\=""(?<x2>[^""]*)""\s+segmentCount\=""(?<x3>[^""]*)""\s+path\=""(?<x4>[^""]*)""[^\>]*\>", RegexOptions.IgnoreCase | RegexOptions.Singleline);
var regexSeg = new Regex(@"\<seg id\=""(?<x1>[^""]*)""\s+pid\=""(?<x2>[^""]*)""\s+status\=""(?<x3>[^""]*)""\s+locked\=""(?<x4>[^""]*)""\s+match\=""(?<x5>[^""]*)""[^\>]*\>" + "\n" + @"(?<x6>.*?)" + "\n" + @"\<\/seg\>" + "\n", RegexOptions.IgnoreCase | RegexOptions.Singleline);
var regexSource = new Regex(@"\{0\>(?<xSource>.*?)\<\}(?<xPercentage>[^\{]*)\{\>", RegexOptions.IgnoreCase | RegexOptions.Singleline);
var matchFile = regexFile.Match(rtb.Text);
if (matchFile.Success)
{
fileAttributes.FileSource = matchFile.Groups["x1"].Value;
fileAttributes.FileTarget = matchFile.Groups["x2"].Value;
fileAttributes.FileSegmentCount = matchFile.Groups["x3"].Value;
fileAttributes.FilePath = matchFile.Groups["x4"].Value;
}
var matchesSeg = regexSeg.Matches(rtb.Text);
foreach (Match matchSeg in matchesSeg)
{
#region | init |
var isSource = false;
var colorFormat = new StringColorType();
var sourceSections = new List <SegmentSection>();
var targetSections = new List <SegmentSection>();
var segmentPairs = new List <SegmentPair>();
var comments = new List <Comment>();
#endregion
var segmentPair = new SegmentPair
{
Id = matchSeg.Groups["x1"].Value,
ParagraphId = matchSeg.Groups["x2"].Value,
SegmentStatus = Core.Processor.GetSegmentStatusFromVisual(matchSeg.Groups["x3"].Value),
IsLocked = Convert.ToBoolean(matchSeg.Groups["x4"].Value),
MatchTypeId = matchSeg.Groups["x5"].Value,
Comments = comments
};
var importTranslation = ImportTranslation(segmentPair);
if (!importTranslation)
{
continue;
}
var content = matchSeg.Groups["x6"].Value;
var paragraphUnit = new ParagraphUnit(segmentPair.ParagraphId, segmentPairs, innerFileName);
var startIndex = matchSeg.Groups["x6"].Index;
var endIndex = startIndex + content.Length;
segmentPair.TranslationOrigin = new TranslationOrigin();;
var matchSource = regexSource.Match(content);
if (matchSource.Success)
{
var text = matchSource.Groups["xSource"].Value;
var percentage = matchSource.Groups["xPercentage"].Value;
if (colorFormat.Black != string.Empty)
{
sourceSections.Add(new SegmentSection(SegmentSection.ContentType.Text, string.Empty, text));
}
segmentPair.Source = Core.Processor.GetSectionsToText(sourceSections);
segmentPair.SourceSections = sourceSections;
startIndex = startIndex + matchSource.Groups["xPercentage"].Index + percentage.Length + 2;
var isTarget = true;
for (var i = startIndex; i <= endIndex; i++)
{
rtb.SelectionStart = i;
rtb.SelectionLength = 1;
text = rtb.Text[i].ToString();
var color = rtb.SelectionColor;
if (color == Color.Black)
{
if (colorFormat.Red != string.Empty)
{
UpdateTagFormatting(colorFormat, isSource ? sourceSections : targetSections);
colorFormat.Red = string.Empty;
colorFormat.Black = string.Empty;
colorFormat.Purple = string.Empty;
colorFormat.Gray = string.Empty;
colorFormat.Black += text;
}
else
{
colorFormat.Black += text;
}
}
else if (color == Color.Red)
{
colorFormat.Red += text;
}
else if (color == Color.Purple)
{
if (colorFormat.Red != string.Empty)
{
UpdateTagFormatting(colorFormat, isSource ? sourceSections : targetSections);
colorFormat.Red = string.Empty;
colorFormat.Black = string.Empty;
colorFormat.Red = string.Empty;
}
colorFormat.Purple += text;
if (!isTarget)
{
continue;
}
if (!colorFormat.Purple.Trim().EndsWith("<0}"))
{
continue;
}
if (colorFormat.Black != string.Empty)
{
targetSections.Add(new SegmentSection(SegmentSection.ContentType.Text, string.Empty, colorFormat.Black));
}
isSource = false;
isTarget = false;
colorFormat.Black = string.Empty;
colorFormat.Purple = string.Empty;
colorFormat.Red = string.Empty;
colorFormat.Gray = string.Empty;
}
else
{
//outside the scope of the markup; error
colorFormat.Misc += text;
}
}
if (colorFormat.Red != string.Empty)
{
UpdateTagFormatting(colorFormat, isSource ? sourceSections : targetSections);
colorFormat.Red = string.Empty;
colorFormat.Black = string.Empty;
colorFormat.Red = string.Empty;
}
isSource = false;
isTarget = false;
colorFormat.Black = string.Empty;
colorFormat.Purple = string.Empty;
colorFormat.Red = string.Empty;
MarkupTagContent(targetSections, ref iTagId);
segmentPair.Target = Core.Processor.GetSectionsToText(targetSections);
segmentPair.TargetSections = targetSections;
paragraphUnit.SegmentPairs.Add(segmentPair);
if (segmentPair.ParagraphId != string.Empty)
{
if (!paragraphUnits.ContainsKey(segmentPair.ParagraphId))
{
paragraphUnits.Add(segmentPair.ParagraphId, paragraphUnit);
}
else
{
paragraphUnits[segmentPair.ParagraphId].SegmentPairs.AddRange(paragraphUnit.SegmentPairs);
}
}
}
indexProcessingCurrent++;
OnProgress(matchesSeg.Count, indexProcessingCurrent, string.Format("Processing segment id: {0}", segmentPair.Id));
}
return(paragraphUnits);
}
