public void SegmentStart(ISegmentPairProperties properties)
{
if (!_tqaDeletion)
{
_buffer.SegmentStart(properties);
}
}
// helper function for creating segment objects
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair, bool source)
{
int i = 1;
ISegment segment = ItemFactory.CreateSegment(pair);
if (source)
{
_srcSegmentTagCount = 0;
if (_totalTagCount < _tmpTotalTagCount)
{
_totalTagCount = _tmpTotalTagCount;
}
}
else
{
_totalTagCount = _totalTagCount - _srcSegmentTagCount;
}
foreach (XmlNode item in segNode.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
segment.Add(CreateText(item.InnerText));
}
if (item.NodeType == XmlNodeType.Element)
{
segment.Add(CreatePhTag(item.Name, item, i, source));
i++;
}
}
return(segment);
}
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair, bool source)
{
ISegment segment = ItemFactory.CreateSegment(pair);
PopulateSegment(segment, segNode, source);
return(segment);
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(xmlUnit.Attributes["status"].Value);
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(xmlUnit.SelectSingleNode("source/seg"), segmentPairProperties);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit if available
if (xmlUnit.SelectSingleNode("target/seg") != null)
{
ISegment trgSegment = CreateSegment(xmlUnit.SelectSingleNode("target/seg"), segmentPairProperties);
paragraphUnit.Target.Add(trgSegment);
}
#region "context"
// create paragraph unit context
string id = xmlUnit.SelectSingleNode("./@id").InnerText;
if (xmlUnit.SelectSingleNode("type/@spec") != null)
{
string spec = xmlUnit.SelectSingleNode("type/@spec").InnerText;
paragraphUnit.Properties.Contexts = CreateContext(spec, id);
}
else
{
paragraphUnit.Properties.Contexts = CreateContext("Paragraph", id);
}
#endregion
#region "comments"
// extract comment (if applicable)
if (xmlUnit.SelectSingleNode("comment") != null)
{
paragraphUnit.Properties.Comments = CreateComment(xmlUnit.SelectSingleNode("comment").InnerText);
}
#endregion
return(paragraphUnit);
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create paragraph unit context
string id = xmlUnit.SelectSingleNode("./@SegID").InnerText;
paragraphUnit.Properties.Contexts = CreateContext("Paragraph", id);
foreach (XmlNode item in xmlUnit.SelectNodes("."))
{
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(item);
tuOrg.MatchPercent = CreateMatchValue(item);
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(_srcDocument.SelectSingleNode("//Seg[@SegID='" + id + "']"), segmentPairProperties, true);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit if available
if (item.SelectSingleNode(".") != null)
{
ISegment trgSegment = CreateSegment(item.SelectSingleNode("."), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
else
{
item.SelectSingleNode(".").InnerText = "";
ISegment trgSegment = CreateSegment(item.SelectSingleNode("."), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
if (tuOrg.MatchPercent > 0)
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
segmentPairProperties.TranslationOrigin = tuOrg;
}
return(paragraphUnit);
}
// helper function for creating segment objects
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair, bool source)
{
try
{
var segment = ItemFactory.CreateSegment(pair);
if (source)
{
_srcSegmentTagCount = 0;
if (_totalTagCount < _tmpTotalTagCount)
{
_totalTagCount = _tmpTotalTagCount;
}
}
else
{
_totalTagCount = _totalTagCount - _srcSegmentTagCount;
}
if (segNode != null)
{
foreach (XmlNode item in segNode.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
segment.Add(CreateText(item.InnerText));
}
if (item.NodeType == XmlNodeType.Element)
{
segment.Add(CreatePhTag(item.Name, item, source));
}
if (item.NodeType == XmlNodeType.Whitespace)
{
segment.Add(CreateText(" "));
}
}
}
return(segment);
}
catch (Exception ex)
{
Log.Logger.Error($"CreateSegment method: {ex.Message}\n {ex.StackTrace}");
}
return(null);
}
// helper function for creating segment objects
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair)
{
ISegment segment = ItemFactory.CreateSegment(pair);
foreach (XmlNode item in segNode.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
segment.Add(CreateText(item.InnerText));
}
if (item.NodeType == XmlNodeType.Element)
{
segment.Add(CreateTagPair(item));
}
}
return(segment);
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create paragraph unit context
segId++;
string id = Convert.ToString(segId);
paragraphUnit.Properties.Contexts = CreateContext("Paragraph", id);
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(xmlUnit);
tuOrg.MatchPercent = this.CreateMatchValue();
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(xmlUnit.SelectSingleNode("tuv[1]/seg"), segmentPairProperties);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit
ISegment trgSegment = CreateSegment(xmlUnit.SelectSingleNode("tuv[2]/seg"), segmentPairProperties);
paragraphUnit.Target.Add(trgSegment);
if (tuOrg.MatchPercent > 0)
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
segmentPairProperties.TranslationOrigin = tuOrg;
return(paragraphUnit);
}
// helper function for creating segment objects
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair, bool source)
{
ISegment segment = ItemFactory.CreateSegment(pair);
if (source)
{
_srcSegment = segment;
srcSegmentTagCount = 0;
if (totalTagCount < tmpTotalTagCount)
{
totalTagCount = tmpTotalTagCount;
}
}
else
{
_trgSegment = segment;
totalTagCount = totalTagCount - srcSegmentTagCount;
}
if (segNode != null)
{
foreach (XmlNode item in segNode.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
segment.Add(CreateText(item.InnerText));
}
if (item.NodeType == XmlNodeType.Element)
{
segment.Add(CreatePhTag(item.Name, item, source));
}
if (item.NodeType == XmlNodeType.Whitespace)
{
segment.Add(CreateText(" "));
}
}
}
return(segment);
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create paragraph unit context
var selectSingleNode = xmlUnit.SelectSingleNode("./@blockId");
if (selectSingleNode != null)
{
string id = selectSingleNode.InnerText;
paragraphUnit.Properties.Contexts = CreateContext(id);
}
var xmlNodeList = xmlUnit.SelectNodes("segment");
if (xmlNodeList != null)
{
foreach (XmlNode item in xmlNodeList)
{
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(item);
tuOrg.MatchPercent = CreateMatchValue(item);
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(item.SelectSingleNode("source"), segmentPairProperties, true);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit if available
if (item.SelectSingleNode("target") != null)
{
ISegment trgSegment = CreateSegment(item.SelectSingleNode("target"), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
else
{
var singleNode = item.SelectSingleNode("source");
if (singleNode != null)
{
singleNode.InnerText = "";
}
ISegment trgSegment = CreateSegment(item.SelectSingleNode("source"), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
if (tuOrg.MatchPercent > 0)
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
segmentPairProperties.TranslationOrigin = tuOrg;
//Add comments
if (item.SelectSingleNode("comments") != null)
{
paragraphUnit.Properties.Comments = CreateComment(item.SelectSingleNode("comments"));
}
}
}
return(paragraphUnit);
}
// enclose each segment in a SPAN tag pair
public override void SegmentStart(ISegmentPairProperties properties)
{
_preview.Write("<span id=\"" + properties.Id.Id + "\" onClick=\"window.external.SelectSegment('" + _paragraphUnitId + "','" + properties.Id.Id + "')\" >");
}
private List <IParagraphUnit> CreateParagraphUnit(XmlNode xmlUnit)
{
List <IParagraphUnit> units = new List <IParagraphUnit>();
var xmlNodes = xmlUnit.SelectNodes("x:trans-unit", nsmgr);
foreach (XmlNode xmlNode in xmlNodes)
{
// Create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
if (xmlNode != null)
{
var id = xmlNode.Attributes["id"];
var paraId = xmlNode.Attributes["m:para-id"];
if (id != null && paraId != null)
{
paragraphUnit.Properties.Contexts = CreateContext(id.Value, paraId.Value);
}
// Create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// Assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(xmlNode);
tuOrg.MatchPercent = CreateMatchValue(xmlNode);
// Add source segment to paragraph unit
ISegment srcSegment = CreateSegment(xmlNode.SelectSingleNode("x:source", nsmgr), segmentPairProperties, true);
paragraphUnit.Source.Add(srcSegment);
// Add target segment to paragraph unit if available
if (xmlNode.SelectSingleNode("x:target", nsmgr) != null)
{
ISegment trgSegment = CreateSegment(xmlNode.SelectSingleNode("x:target", nsmgr), segmentPairProperties, false);
// Check if locked
var locked = xmlNode.Attributes["m:locked"];
if (locked != null && locked.Value == "true")
{
trgSegment.Properties.IsLocked = true;
}
// Check if target empty and look for alt-trans
if (trgSegment.Count == 0)
{
var alttrans = xmlNode.SelectSingleNode("x:alt-trans/x:target", nsmgr);
if (alttrans != null && !string.IsNullOrWhiteSpace(alttrans.InnerText))
{
PopulateSegment(trgSegment, alttrans, false);
var alttransOrigin = xmlNode.SelectSingleNode("x:alt-trans", nsmgr).Attributes["origin"];
if (alttransOrigin != null)
{
var origin = alttransOrigin.Value;
if (origin.Contains("machine") || origin.Contains("mt"))
{
tuOrg.OriginType = DefaultTranslationOrigin.MachineTranslation;
}
else if (origin.Contains("tm"))
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
tuOrg.OriginSystem = origin;
}
}
}
paragraphUnit.Target.Add(trgSegment);
}
else
{
var singleNode = xmlNode.SelectSingleNode("x:source", nsmgr);
if (singleNode != null)
{
singleNode.InnerText = "";
}
ISegment trgSegment = CreateSegment(xmlNode.SelectSingleNode("x:source", nsmgr), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
var transOrigin = xmlNode.Attributes["m:trans-origin"];
if (transOrigin.Value != null && transOrigin.Value != "null")
{
tuOrg.OriginType = transOrigin.Value;
}
segmentPairProperties.TranslationOrigin = tuOrg;
// Add comments
if (xmlNode.SelectSingleNode("m:comment", nsmgr) != null)
{
paragraphUnit.Properties.Comments = CreateComment(xmlNode.SelectSingleNode("m:comment", nsmgr));
}
}
// Clear any ids on the queue
tagIds.Clear();
units.Add(paragraphUnit);
}
return(units);
}
public void WriteEntry(string segmentId, string source, string target, List <string> comments, ISegmentPairProperties segmentProperties)
{
//increase current line number
_currentLine++;
UInt32Value color = GetSegmentMatchColor(segmentProperties.TranslationOrigin);
InsertTextToCell("A", _currentLine, segmentId, color);
InsertTextToCell("B", _currentLine, source, color);
InsertTextToCell("C", _currentLine, target, color);
//Extract comments
if (comments.Count > 0)
{
string commentList = "";
foreach (string item in comments)
{
commentList += item + "\r\n";
}
InsertTextToCell("D", _currentLine, commentList, color);
}
else
{
//Insert empty cell to wrap other cells
InsertTextToCell("D", _currentLine, " ", color);
}
}
// helper function for creating segment objects
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair, bool source)
{
int i = 1;
ISegment segment = ItemFactory.CreateSegment(pair);
if (source)
{
_srcSegmentTagCount = 0;
if (_totalTagCount < _tmpTotalTagCount)
{
_totalTagCount = _tmpTotalTagCount;
}
}
else
{
_totalTagCount = _totalTagCount - _srcSegmentTagCount;
}
foreach (XmlNode item in segNode.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
segment.Add(CreateText(item.InnerText));
}
if (item.NodeType == XmlNodeType.Element)
{
segment.Add(CreatePhTag(item.Name, item, i, source));
i++;
}
}
return segment;
}
public void SetUp()
{
_itemFactoryMock = A.Fake <IDocumentItemFactory>();
_propertiesFactoryMock = A.Fake <IPropertiesFactory>();
_paragraphUnitMock = A.Fake <IParagraphUnit>();
A.CallTo(() => _itemFactoryMock.CreateParagraphUnit(A <LockTypeFlags> .Ignored)).Returns(_paragraphUnitMock);
_paragraphSourceMock = A.Fake <IParagraph>();
A.CallTo(() => _paragraphUnitMock.Source).Returns(_paragraphSourceMock);
_paragraphTargetMock = A.Fake <IParagraph>();
A.CallTo(() => _paragraphUnitMock.Target).Returns(_paragraphTargetMock);
_segmentPairPropertiesMock = A.Fake <ISegmentPairProperties>();
A.CallTo(() => _itemFactoryMock.CreateSegmentPairProperties()).Returns(_segmentPairPropertiesMock);
_translationOriginMmock = A.Fake <ITranslationOrigin>();
A.CallTo(() => _itemFactoryMock.CreateTranslationOrigin()).Returns(_translationOriginMmock);
_sourceSegment0Mock = A.Fake <ISegment>();
_targetSegment0Mock = A.Fake <ISegment>();
_sourceSegment1Mock = A.Fake <ISegment>();
_targetSegment1Mock = A.Fake <ISegment>();
_sourceSegment2Mock = A.Fake <ISegment>();
_targetSegment2Mock = A.Fake <ISegment>();
_sourceSegment3Mock = A.Fake <ISegment>();
_targetSegment3Mock = A.Fake <ISegment>();
A.CallTo(() => _itemFactoryMock.CreateSegment(A <ISegmentPairProperties> .Ignored))
.ReturnsNextFromSequence(
_sourceSegment0Mock, _targetSegment0Mock,
_sourceSegment1Mock, _targetSegment1Mock,
_sourceSegment2Mock, _targetSegment2Mock,
_sourceSegment3Mock, _targetSegment3Mock
);
var textPropertiesMsgidMock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message id")).Returns(textPropertiesMsgidMock);
var textPropertiesMsgidPluralMock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message id plural"))
.Returns(textPropertiesMsgidPluralMock);
var textPropertiesMsgstrMock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string"))
.Returns(textPropertiesMsgstrMock);
var textPropertiesMsgstr0Mock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string 0"))
.Returns(textPropertiesMsgstr0Mock);
var textPropertiesMsgstr1Mock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string 1"))
.Returns(textPropertiesMsgstr1Mock);
var textPropertiesMsgstr2Mock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string 2"))
.Returns(textPropertiesMsgstr2Mock);
_textMsgidMock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgidMock)).Returns(_textMsgidMock);
_textMsgidPluralMock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgidPluralMock)).Returns(_textMsgidPluralMock);
_textMsgstrMock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstrMock)).Returns(_textMsgstrMock);
_textMsgstr0Mock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstr0Mock)).Returns(_textMsgstr0Mock);
_textMsgstr1Mock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstr1Mock)).Returns(_textMsgstr1Mock);
_textMsgstr2Mock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstr2Mock)).Returns(_textMsgstr2Mock);
}
public void WriteEntry(string segmentId, string source, string target, List<string> comments, ISegmentPairProperties segmentProperties)
{
//increase current line number
_currentLine++;
UInt32Value color = GetSegmentMatchColor(segmentProperties.TranslationOrigin);
InsertTextToCell("A", _currentLine, segmentId, color);
InsertTextToCell("B", _currentLine, source, color);
InsertTextToCell("C", _currentLine, target, color);
//Extract comments
if (comments.Count > 0)
{
string commentList = "";
foreach (string item in comments)
{
commentList += item + "\r\n";
}
InsertTextToCell("D", _currentLine, commentList, color);
}
else
{
//Insert empty cell to wrap other cells
InsertTextToCell("D", _currentLine, " ", color);
}
}
// helper function for creating segment objects
private ISegment CreateSegment(XmlNode segNode, ISegmentPairProperties pair)
{
int i = 1;
ISegment segment = ItemFactory.CreateSegment(pair);
foreach (XmlNode item in segNode.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
segment.Add(CreateText(item.InnerText));
}
if (item.NodeType == XmlNodeType.Element)
{
segment.Add(CreatePhTag(item.Name, item, i));
i++;
}
}
return segment;
}
private void SwitchTranslation(ISegmentPair segmentPair, ISegment updatedSegment, ISegmentPairProperties updatedProperties)
{
segmentPair.Target.Clear();
foreach (var item in updatedSegment)
{
segmentPair.Target.Add(item.Clone() as IAbstractMarkupData);
}
_studioDocument.UpdateSegmentPair(segmentPair);
segmentPair.Properties.ConfirmationLevel = updatedProperties.ConfirmationLevel;
segmentPair.Properties.TranslationOrigin = updatedProperties.TranslationOrigin?.Clone() as ITranslationOrigin;
segmentPair.Properties.IsLocked = updatedProperties.IsLocked;
_studioDocument.UpdateSegmentPairProperties(segmentPair, segmentPair.Properties);
}
// enclose each segment in a SPAN tag pair
public override void SegmentStart(ISegmentPairProperties properties)
{
_preview.Write("<span>");
}
public ISegment CreateSegment(ISegmentPairProperties segmentPairProperties)
{
return(ItemFactory.CreateSegment(segmentPairProperties));
}
