public XamlParserResults(ITypeId expectedRootType, DocumentNode rootNode, IList <XamlParseError> errors, INodeSourceContext xmlDocumentReference, IReadableSelectableTextBuffer textBuffer)
{
this.expectedRootType = expectedRootType;
this.rootNode = rootNode;
this.errors = errors;
this.xmlDocumentReference = (XmlDocumentReference)xmlDocumentReference;
this.textBuffer = textBuffer;
}
public static void UpdateNodeSourceContext(IReadableSelectableTextBuffer textBuffer, DocumentNode node, int startTagLength, int elementLength)
{
DocumentNode node1 = (DocumentNode)node.Parent;
if (node1 != null && typeof(DictionaryEntry).IsAssignableFrom(node1.TargetType) && node1.SourceContext is XmlElementReference)
{
XamlSerializerUtilities.UpdateNodeSourceContextWorker(textBuffer, node1, startTagLength, elementLength);
}
XamlSerializerUtilities.UpdateNodeSourceContextWorker(textBuffer, node, startTagLength, elementLength);
}
private static void UpdateSourceContextRangeFromInitialRangeWorker(IReadableSelectableTextBuffer textBuffer, DocumentNode node, int offset)
{
node.ClearOldSourceContainerContext();
XamlSerializerUtilities.UpdateSourceContextRangeFromInitialRange(textBuffer, node.SourceContext, offset);
XamlSerializerUtilities.UpdateSourceContextRangeFromInitialRange(textBuffer, node.ContainerSourceContext, offset);
foreach (DocumentNode node1 in node.ChildNodes)
{
XamlSerializerUtilities.UpdateSourceContextRangeFromInitialRangeWorker(textBuffer, node1, offset);
}
}
protected XamlSourceContext(XmlContainerReference parent, IReadableSelectableTextBuffer textBuffer, SourceContext sourceContext, bool beginTracking)
{
this.parent = parent;
if (!beginTracking)
{
return;
}
this.textRange = XamlSourceContext.ToTextRange(textBuffer, sourceContext);
this.ordering = sourceContext.StartCol;
}
public RemovedXmlAttributeReference(XmlAttributeReference originalReference, bool isClone)
: base((XmlElementReference)originalReference.Parent)
{
originalReference.CloneCopy((XamlSourceContext)this, false);
this.textBuffer = originalReference.TextBuffer.Freeze();
if (originalReference.TextRange != null)
{
this.TextRange = this.textBuffer.FreezeRange(originalReference.TextRange);
}
this.isCloned = isClone;
}
internal static ITextRange ToTextRange(IReadableSelectableTextBuffer textBuffer, SourceContext sourceContext)
{
int offset = sourceContext.StartCol;
int num = sourceContext.EndCol;
int length = textBuffer.Length;
if (num > length)
{
num = length;
}
return(textBuffer.CreateRange(offset, num - offset));
}
public string GetIndent(string childIndent)
{
if (this.documentNode == null)
{
return(string.Empty);
}
DocumentCompositeNode parent = this.documentNode.Parent;
if (parent == null)
{
return(string.Empty);
}
XamlSourceContext xamlSourceContext = (XamlSourceContext)null;
if (this.documentNode.IsChild)
{
for (int index = this.documentNode.SiteChildIndex - 1; index >= 0; --index)
{
xamlSourceContext = parent.Children[index].SourceContext as XamlSourceContext;
if (xamlSourceContext != null && xamlSourceContext.TextRange != null)
{
break;
}
}
}
bool flag = false;
while (parent != null && (xamlSourceContext == null || xamlSourceContext.TextRange == null))
{
xamlSourceContext = parent.SourceContext as XamlSourceContext ?? parent.ContainerSourceContext as XamlSourceContext;
parent = parent.Parent;
flag = true;
}
if (xamlSourceContext == null)
{
return(string.Empty);
}
IReadableSelectableTextBuffer hostBuffer = TextBufferHelper.GetHostBuffer(xamlSourceContext.TextBuffer);
ITextRange textRange = TextBufferHelper.ExpandSpanLeftToFillWhitespace((IReadableTextBuffer)hostBuffer, (ITextRange) new TextRange(xamlSourceContext.TextRange.Offset, xamlSourceContext.TextRange.Offset));
string str = hostBuffer.GetText(textRange.Offset, textRange.Length);
int num = str.LastIndexOf('\n');
if (num != -1)
{
str = str.Substring(num + 1);
}
if (flag)
{
str += childIndent;
}
return(str);
}
public static int GetStartOfXmlCloseTag(IReadableSelectableTextBuffer textBuffer, int elementEnd)
{
if (elementEnd <= 0)
{
return(0);
}
int offset = elementEnd - 1;
while (offset >= 0 && (int)textBuffer.GetText(offset, 1)[0] != 60)
{
--offset;
}
return(offset);
}
private static void UpdateNodeSourceContextWorker(IReadableSelectableTextBuffer textBuffer, DocumentNode node, int startTagLength, int elementLength)
{
XmlElementReference elementReference1 = (XmlElementReference)node.SourceContext;
XmlElementReference elementReference2 = (XmlElementReference)elementReference1.Clone(false);
if (startTagLength != elementLength)
{
elementReference2.StartTagRange = textBuffer.CreateRange(elementReference1.TextRange.Offset, startTagLength);
}
elementReference2.SetTextRange(textBuffer, elementReference1.TextRange.Offset, elementLength);
if (node.DocumentRoot != null)
{
node.DocumentRoot.SetSourceContext(node, (INodeSourceContext)elementReference2);
}
else
{
node.SourceContext = (INodeSourceContext)elementReference2;
}
}
public RemovedXmlElementReference(XmlElementReference originalReference, bool isClone)
: base(originalReference.Parent, new SourceContext(), new SourceContext(), false)
{
originalReference.CloneCopy((XamlSourceContext)this, false);
this.textBuffer = originalReference.TextBuffer.Freeze();
if (this.Comment != null && this.Comment.SourceContext != null)
{
this.Comment.SourceContext.FreezeText(isClone);
}
if (originalReference.TextRange != null)
{
this.TextRange = this.textBuffer.FreezeRange(originalReference.TextRange);
}
if (originalReference.StartTagRange != null)
{
this.StartTagRange = this.textBuffer.FreezeRange(originalReference.StartTagRange);
}
this.isCloned = isClone;
}
public static int GetEndOfXmlElementName(IReadableSelectableTextBuffer textBuffer, TextRange startTagSpan)
{
int offset = startTagSpan.Offset + 1;
while (offset < startTagSpan.Offset + startTagSpan.Length)
{
int length = Math.Min(32, startTagSpan.Offset + startTagSpan.Length - offset);
string text = textBuffer.GetText(offset, length);
for (int index = 0; index < text.Length; ++index)
{
if (Scanner.IsXmlWhitespace(text[index]) || (int)text[index] == 47 || (int)text[index] == 62)
{
return(offset + index);
}
}
offset += length;
}
return(offset);
}
private static void UpdateSourceContextRangeFromInitialRange(IReadableSelectableTextBuffer textBuffer, INodeSourceContext context, int offset)
{
XamlSourceContext xamlSourceContext = context as XamlSourceContext;
if (xamlSourceContext == null)
{
return;
}
if (!TextRange.IsNull(xamlSourceContext.InitialTextSpan))
{
ITextRange initialTextSpan = xamlSourceContext.InitialTextSpan;
ITextRange textRange1 = (ITextRange) new TextRange(initialTextSpan.Offset + offset, initialTextSpan.Offset + initialTextSpan.Length + offset);
xamlSourceContext.InitialTextSpan = textRange1;
xamlSourceContext.SetTextRange(textBuffer, textRange1.Offset, textRange1.Length);
XmlElementReference elementReference = xamlSourceContext as XmlElementReference;
if (elementReference == null)
{
return;
}
foreach (XmlElementReference.Attribute attribute in elementReference.AttributesToPreserve)
{
XamlSerializerUtilities.UpdateSourceContextRangeFromInitialRange(textBuffer, (INodeSourceContext)attribute.SourceContext, offset);
}
if (TextRange.IsNull(elementReference.InitialStartTagSpan))
{
return;
}
ITextRange initialStartTagSpan = elementReference.InitialStartTagSpan;
ITextRange textRange2 = (ITextRange) new TextRange(initialStartTagSpan.Offset + offset, initialStartTagSpan.Offset + initialStartTagSpan.Length + offset);
elementReference.InitialStartTagSpan = textRange2;
elementReference.StartTagRange = textBuffer.CreateRange(textRange2.Offset, textRange2.Length);
}
else
{
xamlSourceContext.ClearTextRange();
XmlElementReference elementReference = xamlSourceContext as XmlElementReference;
if (elementReference == null)
{
return;
}
elementReference.StartTagRange = (ITextRange)null;
}
}
public static ITextRange GetElementNameSelectionSpan(IReadableSelectableTextBuffer textBuffer, ITextRange elementSpan)
{
int start = elementSpan.Offset + 1;
int num = elementSpan.Length - 1;
int offset = start;
while (offset < textBuffer.Length)
{
int length = Math.Min(32, textBuffer.Length - offset);
string text = textBuffer.GetText(offset, length);
for (int index = 0; index < text.Length; ++index)
{
if (char.IsWhiteSpace(text[index]) || (int)text[index] == 47 || (int)text[index] == 62)
{
num = index + offset - start;
offset = textBuffer.Length;
break;
}
}
offset += length;
}
return((ITextRange) new TextRange(start, start + num));
}
public static IReadableSelectableTextBuffer GetHostBuffer(IReadableSelectableTextBuffer textBuffer)
{
return(textBuffer);
}
public static XamlParserResults Parse(IDocumentContext context, ITypeId expectedRootType, IReadableSelectableTextBuffer textBuffer)
{
return(new XamlParser(context, textBuffer, expectedRootType).Parse());
}
internal XmlDocumentReference(IReadableSelectableTextBuffer textBuffer, SourceContext sourceContext, string encoding, bool beginTracking)
: base((XmlContainerReference)null, textBuffer, sourceContext, beginTracking)
{
this.textBuffer = textBuffer;
this.encoding = encoding;
}
internal XmlDocumentReference(IReadableSelectableTextBuffer textBuffer, XmlDocument xmlDocument, bool beginTracking)
: this(textBuffer, xmlDocument.SourceContext, xmlDocument.Encoding, beginTracking)
{
}
protected XmlContainerReference(XmlContainerReference parent, IReadableSelectableTextBuffer textBuffer, SourceContext sourceContext, bool beginTracking)
: base(parent, textBuffer, sourceContext, beginTracking)
{
}
public static void UpdateSourceContextRangeFromInitialRange(IReadableSelectableTextBuffer textBuffer, DocumentNode node, int offset)
{
XamlSerializerUtilities.UpdateSourceContextRangeFromInitialRangeWorker(textBuffer, node, offset);
XamlSerializerUtilities.RefreshSiblingOrdering(node);
}
public static XamlParseError XmlError(ErrorNode errorNode, IReadableSelectableTextBuffer textBuffer, int offset)
{
return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.XmlError, textBuffer.GetLocation(errorNode.SourceContext.StartCol + offset), errorNode.ErrorCode, errorNode.ErrorParameters));
}
public void SetTextRange(IReadableSelectableTextBuffer textBuffer, int offset, int length)
{
this.textRange = textBuffer.CreateRange(offset, length);
this.ordering = offset;
}
