private static void RandomizeTag(IAbstractMarkupData markupData)
{
if (markupData is IPlaceholderTag tag)
{
tag.Properties.TagId = new TagId(Guid.NewGuid().ToString());
}
}
public void VisitPlaceholderTag(IPlaceholderTag tag)
{
if (ElementTypeToSearch == Token.TokenType.TagPlaceholder && tag.TagProperties.TagId.Id == ElementIdToSearch)
{
FoundElement = tag;
}
}
private void DeleteNode(IAbstractMarkupData node)
{
//Remove node from tree
int index = node.IndexInParent;
IAbstractMarkupDataContainer parent = node.Parent;
node.RemoveFromParent();
//If this is a deleted revision marker then no more processing is required
IRevisionMarker revisionMarker = node as IRevisionMarker;
if (revisionMarker != null)
{
if (revisionMarker.Properties.RevisionType == revisionTypeToIgnore)
{
return;
}
}
//If a comment or inserted revision then copy children to parent at the index location of the original node we have removed
IAbstractMarkupDataContainer container = node as IAbstractMarkupDataContainer;
if (container.Count() > 0)
{
container.MoveItemsTo(parent, index, 0, container.Count());
}
}
private static void MergeMarkupData(ISegment segment, IDocumentItemFactory itemFactory, IPropertiesFactory propFactory)
{
Location textLocation = new Location(segment, true);
IText prevText = null;
do
{
if (textLocation.ItemAtLocation != null)
{
IAbstractMarkupData currData = (IAbstractMarkupData)textLocation.ItemAtLocation.Clone();
IText currText = currData as IText;
if (currText == null)
{
prevText = null;
}
else
if (prevText == null)
{
prevText = currText;
}
else
{
prevText = itemFactory.CreateText(propFactory.CreateTextProperties(prevText.Properties.Text +
currText.Properties.Text));
textLocation.ItemAtLocation.Parent.RemoveAt(textLocation.ItemAtLocation.IndexInParent);
textLocation.MovePrevious();
textLocation.ItemAtLocation.Parent[textLocation.ItemAtLocation.IndexInParent] = prevText;
}
}
}while (textLocation.MoveNextSibling());
}
public void VisitPlaceholderTag(IPlaceholderTag tag)
{
if (_element is ElementPlaceholder && tag.TagProperties.TagId.Id == _elementIdToSearch)
{
FoundElement = tag;
}
}
public void VisitLockedContent(ILockedContent lockedContent)
{
if (ElementTypeToSearch == Token.TokenType.LockedContent && _currentLockedContentId.ToString() == ElementIdToSearch)
{
FoundElement = lockedContent;
}
_currentLockedContentId++;
}
private void InsertTextBack(IAbstractMarkupData abstractMarkupData, IPlaceholderTag tag)
{
var elementContainer = abstractMarkupData.Parent;
var untagedText = _documentItemFactory.CreateText(_propertiesFactory.CreateTextProperties(tag.Properties.TagContent));
elementContainer.Insert(tag.IndexInParent, untagedText);
elementContainer.RemoveAt(tag.IndexInParent);
}
private static bool IsRemovableItem(IAbstractMarkupData item)
{
return(typeof(IText).IsAssignableFrom(item.GetType()) ||
typeof(ICommentMarker).IsAssignableFrom(item.GetType()) ||
typeof(ILocationMarker).IsAssignableFrom(item.GetType()) ||
typeof(ILockedContent).IsAssignableFrom(item.GetType()) ||
typeof(IOtherMarker).IsAssignableFrom(item.GetType()) ||
typeof(IRevisionMarker).IsAssignableFrom(item.GetType()));
}
public IAbstractMarkupData GetTag(string elementID, IAbstractMarkupDataContainer objectToSearch, Token.TokenType tokenType)
{
ElementIdToSearch = elementID;
ElementTypeToSearch = tokenType;
FoundElement = null;
_currentLockedContentId = 0;
VisitChildren(objectToSearch);
return(FoundElement);
}
public void VisitTagPair(ITagPair tagPair)
{
if ((ElementTypeToSearch == Token.TokenType.TagOpen || ElementTypeToSearch == Token.TokenType.TagClose) && tagPair.TagProperties.TagId.Id == ElementIdToSearch)
{
FoundElement = tagPair;
}
VisitChildren(tagPair);
}
public void VisitLockedContent(ILockedContent lockedContent)
{
if (_element is ElementLocked && _currentLockedContentId.ToString() == _elementIdToSearch)
{
FoundElement = lockedContent;
}
_currentLockedContentId++;
}
private void Log(IAbstractMarkupData data, string tagContent)
{
IAbstractMarkupDataContainer parent = data.Parent;
while (!(parent is ISegment))
{
parent = ((IAbstractMarkupData)parent).Parent;
}
var segment = (ISegment)parent;
reportGenerator.AddTagItem(segment.Properties.Id.Id, tagContent);
}
private static void CopyParagraph(IParagraph fromParagraph, IParagraph toParagraph)
{
toParagraph.Clear();
while (fromParagraph.Count > 0)
{
IAbstractMarkupData markupData = fromParagraph[0];
fromParagraph.RemoveAt(0);
toParagraph.Add(markupData);
}
}
public void VisitTagPair(ITagPair tagPair)
{
if (_element is ElementTagPair elementTagPair)
{
if (elementTagPair.Type == Element.TagType.OpeningTag || elementTagPair.Type == Element.TagType.ClosingTag &&
tagPair.TagProperties.TagId.Id == _elementIdToSearch)
{
FoundElement = tagPair;
}
VisitChildren(tagPair);
}
}
//check if the markup is in the list of the markups visited
private bool ListContainsMarkupData(IAbstractMarkupData theMarkupData)
{
var contains = false;
//Why isn't the text in a PlaceHolder in the segment?
var newItemLocation = IsAncestorOfMarkup(theMarkupData, _segment) ? new Location(_segment, theMarkupData) : new Location(theMarkupData.Parent, theMarkupData);
foreach (var item in _markupsListVisited)
{
if (item.Equals(theMarkupData))
{
var itemLocation = IsAncestorOfMarkup(theMarkupData, _segment) ? new Location(_segment, item) : new Location(item.Parent, item);
contains = itemLocation.Equals(newItemLocation);
}
}
return(contains);
}
public void VisitPlaceholderTag(IPlaceholderTag tag)
{
if (FoundElement != null)
{
return;
}
// Dev Notes: should handle the tagContentId differently; potentially have priority
var tagContentId = GetTagContentId(tag.TagProperties.TagContent);
if (_element is ElementPlaceholder &&
(tag.TagProperties.TagId.Id == _elementIdToSearch || tagContentId == _elementIdToSearch))
{
FoundElement = tag;
}
}
//check if "theAncestor" is an ancestor of "theMarkupData"
private bool IsAncestorOfMarkup(IAbstractMarkupData theMarkupData, ISegment theAncestor)
{
var ret = false;
if (theMarkupData == null || theAncestor == null)
{
return(ret);
}
var parent = theMarkupData.Parent;
if (parent == null)
{
return(ret);
}
ret = parent.Equals(theAncestor) || theAncestor.Contains(theMarkupData);
return(ret);
}
//check if "theAncestor" is an ancestor of "theMarkupData"
private bool IsAncestorOfMarkup(IAbstractMarkupData theMarkupData, ISegment theAncestor)
{
bool ret = false;
if (theMarkupData != null && theAncestor != null)
{
IAbstractMarkupDataContainer parent = theMarkupData.Parent;
if (parent != null)
{
if (parent.Equals(theAncestor))
{
ret = true;
}
else
{
ret = theAncestor.Contains(theMarkupData);
}
}
}
return(ret);
}
public void VisitTagPair(ITagPair tagPair)
{
if (FoundElement != null)
{
return;
}
if (_element is ElementTagPair elementTagPair)
{
// Dev Notes: should handle the tagContentId differently; potentially have priority
var tagContentId = GetTagContentId(tagPair.TagProperties.TagContent);
if ((elementTagPair.Type == Element.TagType.TagOpen || elementTagPair.Type == Element.TagType.TagClose) &&
(tagPair.TagProperties.TagId.Id == _elementIdToSearch || tagContentId == _elementIdToSearch))
{
FoundElement = tagPair;
}
VisitChildren(tagPair);
}
}
protected virtual bool HasEmbededContent(IAbstractMarkupData markupData)
{
var tagPair = _currentContainer as ITagPair;
if (tagPair == null)
{
return(false);
}
var metaDataContainer = tagPair.StartTagProperties as IMetaDataContainer;
if (metaDataContainer == null || !metaDataContainer.HasMetaData)
{
return(false);
}
if (!metaDataContainer.MetaDataContainsKey(IsCData))
{
return(false);
}
return(bool.Parse(metaDataContainer.GetMetaData(IsCData)));
}
/// <summary>
/// Insert item to the proper container
/// </summary>
/// <param name="vector"></param>
/// <param name="segment"></param>
/// <param name="abstractItem"></param>
private void InsertItemOnLocation(IEnumerable <int> vector, ref ISegment segment, IAbstractMarkupData abstractItem)
{
IAbstractMarkupDataContainer currentContainer = segment;
foreach (var index in vector)
{
currentContainer = (IAbstractMarkupDataContainer)currentContainer[index];
}
currentContainer.Add(abstractItem);
}
protected virtual bool HasEmbededContent(IAbstractMarkupData markupData)
{
var tagPair = _currentContainer as ITagPair;
if (tagPair == null) return false;
var metaDataContainer = tagPair.StartTagProperties as IMetaDataContainer;
if (metaDataContainer == null || !metaDataContainer.HasMetaData) return false;
if (!metaDataContainer.MetaDataContainsKey(IsCData)) return false;
return bool.Parse(metaDataContainer.GetMetaData(IsCData));
}
public IEnumerator <IAbstractMarkupData> AbstractMarkupDataContainer(IAbstractMarkupData data)
{
yield return(data);
}
