internal ResolveResult ResolveElement(AXmlElement element, CancellationToken cancellationToken = default(CancellationToken))
{
string namespaceName = element.Namespace;
string name = element.LocalName;
if (name.Contains("."))
{
string propertyName = name.Substring(name.IndexOf('.') + 1);
name = name.Substring(0, name.IndexOf('.'));
ITypeReference reference = XamlUnresolvedFile.CreateTypeReference(namespaceName, name);
IType type = reference.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly));
IMember member = FindMember(type, propertyName);
IMember underlying = null;
if (member == null)
{
member = FindAttachedMember(type, propertyName, out underlying);
}
if (member == null)
{
return(new UnknownMemberResolveResult(type, propertyName, EmptyList <IType> .Instance));
}
if (underlying != null)
{
return(new AttachedMemberResolveResult(new TypeResolveResult(type), underlying, member));
}
return(new MemberResolveResult(new TypeResolveResult(type), member));
}
else
{
ITypeReference reference = XamlUnresolvedFile.CreateTypeReference(namespaceName, name);
IType type = reference.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly));
return(new TypeResolveResult(type));
}
}
/// <summary> Visit AXmlElement </summary>
public virtual void VisitElement(AXmlElement element)
{
foreach (AXmlObject child in element.Children)
{
child.AcceptVisitor(this);
}
}
public ElementWrapper(AXmlElement element)
{
this.LocalName = element.LocalName;
this.Prefix = element.Prefix;
this.Namespace = element.Namespace;
this.Offset = element.StartOffset;
this.Attributes = element.Attributes.Select(attr => new AttributeWrapper(attr)).ToList();
}
IList <ICompletionItem> CreateAttributeList(XamlCompletionContext context, bool includeEvents)
{
if (context.ParseInformation == null)
{
return(EmptyList <ICompletionItem> .Instance);
}
AXmlElement lastElement = context.ActiveElement;
IUnresolvedFile file = context.ParseInformation.UnresolvedFile;
XamlResolver resolver = new XamlResolver(compilation);
IType type = resolver.ResolveType(lastElement.Namespace, lastElement.LocalName.Trim('.'));
var list = new List <ICompletionItem>();
string xamlPrefix = context.XamlNamespacePrefix;
string xKey = string.IsNullOrEmpty(xamlPrefix) ? "" : xamlPrefix + ":";
if (lastElement.Prefix == context.XamlNamespacePrefix && XamlConst.IsBuiltin(lastElement.LocalName))
{
return(EmptyList <ICompletionItem> .Instance);
}
if (lastElement.LocalName.EndsWith(".", StringComparison.OrdinalIgnoreCase) || context.PressedKey == '.')
{
if (type.Kind == TypeKind.Unknown)
{
return(EmptyList <ICompletionItem> .Instance);
}
if (context.ParentElement != null &&
context.ParentElement.LocalName.StartsWith(lastElement.LocalName.TrimEnd('.'), StringComparison.OrdinalIgnoreCase))
{
AddAttributes(type, list, includeEvents);
}
AddAttachedProperties(type.GetDefinition(), list);
}
else
{
if (type.Kind == TypeKind.Unknown)
{
list.Add(new XamlCompletionItem(xKey + "Uid"));
}
else
{
AddAttributes(type, list, includeEvents);
list.AddRange(GetListOfAttached(context, null, includeEvents, true));
list.AddRange(
XamlConst.XamlNamespaceAttributes
.Where(localName => XamlConst.IsAttributeAllowed(context.InRoot, localName))
.Select(item => new XamlCompletionItem(xKey + item))
);
}
}
return(list);
}
public static String GetPath(AXmlElement activeElement)
{
String path = activeElement.Name;
AXmlElement parent = activeElement;
while ((parent = AXmlFinder.FindOwnerElement(parent, false)) != null)
{
path = parent.Name + "\\" + path;
}
return(path);
}
public int GetIndex(AXmlObject objToSearch, bool CountCommentAsElement)
{
int index = 0;
bool isInList = false;
if (objToSearch != null && objToSearch.Parent != null && objToSearch.Parent is AXmlElement)
{
AXmlElement parent = objToSearch.Parent as AXmlElement;
AXmlObject temp = objToSearch.Parent;
while (parent == null && temp != null)
{
parent = parent.Parent as AXmlElement;
temp = temp.Parent;
}
if (parent != null)
{
foreach (AXmlObject obj in parent.Children)
{
if (obj.Equals(objToSearch))
{
isInList = true;
break;//순서를 찾았다.
}
else if (objToSearch is AXmlElement && obj is AXmlElement)
{
index++;
}
else if (objToSearch is AXmlTag && (objToSearch as AXmlTag).OpeningBracket.Equals("<!--") && obj is AXmlElement)
{
if (CountCommentAsElement)
{
index++;
}
}
else if (obj is AXmlTag && (obj as AXmlTag).OpeningBracket.Equals("<!--"))
{
if (CountCommentAsElement)
{
index++;
}
}
}
}
}
if (isInList)
{
return(index);
}
else
{
return(-1);
}
}
public ElementContext(SourceFile file, AXmlElement element, ElementContext parent)
{
_file = file;
_element = element;
_parent = parent;
_children = _element.Children
.OfType <AXmlElement>()
.Select(elm => new ElementContext(_file, elm, this)).ToArray();
_attributes = _element.Attributes.Select(a => new Attribute(_file, a)).ToArray();
}
public static AXmlAttribute GetAttribute(AXmlElement element, String attrName)
{
foreach (AXmlAttribute attr in element.Attributes)
{
if (attr.Name.Equals(attrName))
{
return(attr);
break;
}
}
return(null);
}
XamlOutlineNode BuildNode(AXmlElement item)
{
XamlOutlineNode node = new XamlOutlineNode {
Name = item.GetAttributeValue("Name") ?? item.GetAttributeValue(XamlConst.XamlNamespace, "Name"),
ElementName = item.Name,
Marker = editor.Document.CreateAnchor(Utils.MinMax(item.StartOffset, 0, editor.Document.TextLength - 1)),
EndMarker = editor.Document.CreateAnchor(Utils.MinMax(item.EndOffset, 0, editor.Document.TextLength - 1)),
Editor = editor
};
foreach (var child in item.Children.OfType <AXmlElement>())
{
node.Children.Add(BuildNode(child));
}
return(node);
}
IClass AddClass(string className, AXmlElement element)
{
if (projectContent.Language == LanguageProperties.VBNet && projectContent.Project is IProject)
{
className = ((IProject)projectContent.Project).RootNamespace + "." + className;
}
DefaultClass c = new DefaultClass(CompilationUnit, className);
string modifierValue = (element.GetAttributeValue(CompletionDataHelper.XamlNamespace, "ClassModifier") ?? string.Empty).Trim();
c.Modifiers = ModifierEnum.Partial;
string internalString = currentAmbience.ConvertAccessibility(ModifierEnum.Internal).Trim();
if (projectContent.Language.NameComparer.Compare(modifierValue, internalString) == 0)
{
c.Modifiers |= ModifierEnum.Internal;
}
else
{
c.Modifiers |= ModifierEnum.Public;
}
c.Region = CreateRegion(element.StartOffset, element.EndOffset);
var baseType = TypeFromXmlNode(CompilationUnit, element);
if (baseType != null)
{
c.BaseTypes.Add(baseType);
}
CompilationUnit.Classes.Add(c);
DefaultMethod initializeComponent = new DefaultMethod(
"InitializeComponent",
projectContent.SystemTypes.Void,
ModifierEnum.Public | ModifierEnum.Synthetic, c.Region, DomRegion.Empty,
c);
c.Methods.Add(initializeComponent);
return(c);
}
public override void VisitElement(AXmlElement element)
{
string name = element.GetAttributeValue(XamlConst.XamlNamespace, "Name") ??
element.GetAttributeValue("Name");
string modifier = element.GetAttributeValue(XamlConst.XamlNamespace, "FieldModifier");
if (name != null && TypeDefinition != null)
{
var field = new DefaultUnresolvedField(TypeDefinition, name);
field.Accessibility = Accessibility.Internal;
field.ReturnType = CreateTypeReference(element.Namespace, element.LocalName);
field.Region = new DomRegion(file.FileName, textDocument.GetLocation(element.StartOffset), textDocument.GetLocation(element.EndOffset));
if (modifier != null)
{
field.Accessibility = ParseAccessibility(modifier);
}
TypeDefinition.Members.Add(field);
}
base.VisitElement(element);
}
public static List <AXmlObject> GetXmlElementPair(AXmlDocument xDoc, AXmlObject xmlObj)
{
List <AXmlObject> tsList = new List <AXmlObject>();
AXmlElement ele = FindOwnerElement(xmlObj, true);
if (ele == null)
{
return(new List <AXmlObject>());
}
if (ele.HasStartOrEmptyTag)
{
tsList.Add(ele.Children[0]);
}
if (ele.HasEndTag)
{
tsList.Add(ele.Children[ele.Children.Count - 1]);
}
return(tsList);
}
public override void VisitElement(AXmlElement element)
{
AXmlTag tag = element.Children.FirstOrDefault() as AXmlTag;
if (tag != null && tag.IsStartOrEmptyTag)
{
NodeWrapper node = new NodeWrapper()
{
ElementName = element.LocalName,
StartOffset = element.StartOffset,
EndOffset = element.EndOffset,
Name = element.GetAttributeValue("Name") ?? element.GetAttributeValue(CompletionDataHelper.XamlNamespace, "Name"),
Children = new List <NodeWrapper>()
};
if (CompilationUnit.TreeRootNode == null)
{
CompilationUnit.TreeRootNode = node;
nodeStack.Push(CompilationUnit.TreeRootNode);
}
else
{
if (nodeStack.Count > 0)
{
nodeStack.Peek().Children.Add(node);
}
if (!tag.IsEmptyTag)
{
nodeStack.Push(node);
}
}
}
base.VisitElement(element);
if (tag != null && tag.IsStartTag)
{
nodeStack.PopOrDefault();
}
}
/// <summary>
/// 부모노드에서 몇번째에 속한 element인지를 찾는다.
/// </summary>
/// <param name="element">index를 찾을 element</param>
/// <param name="CountCommentAsElement">Comment를 Element로 인식하고 count할 것인지 여부</param>
/// <returns>element의 index가 부모노드에서 몇번인지. 0 based.</returns>
public static int GetIndexFromParent(AXmlElement element, bool CountCommentAsElement = true)
{
AXmlElement parent = element.Parent as AXmlElement;
AXmlObject temp = element.Parent;
int index = 0;
while (parent == null && temp != null)
{
parent = parent.Parent as AXmlElement;
temp = temp.Parent;
}
if (parent != null)
{
foreach (AXmlObject obj in parent.Children)
{
if (obj.Equals(element))
{
return(index);
break;//순서를 찾았다.
}
else if (element is AXmlElement && obj is AXmlElement)
{
index++;
}
else if (obj is AXmlTag && (obj as AXmlTag).OpeningBracket.Equals("<!--"))
{
if (CountCommentAsElement)
{
index++;
}
}
}
}
return(-1);
}
public IList <ICompletionItem> CreateElementList(XamlCompletionContext context, bool includeAbstract)
{
if (context.ParseInformation == null)
{
return(EmptyList <ICompletionItem> .Instance);
}
List <ICompletionItem> result = new List <ICompletionItem>();
AXmlElement last = context.ParentElement;
ITextEditor editor = context.Editor;
compilation = SD.ParserService.GetCompilationForFile(editor.FileName);
IUnresolvedFile file = context.ParseInformation.UnresolvedFile;
foreach (string item in XamlConst.GetAllowedItems(context))
{
result.Add(new XamlCompletionItem(item));
}
IType rt = null;
if (last != null)
{
if (string.Equals(last.Prefix, context.XamlNamespacePrefix, StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(last.LocalName, "Members", StringComparison.OrdinalIgnoreCase))
{
return(result);
}
if (string.Equals(last.LocalName, "Code", StringComparison.OrdinalIgnoreCase))
{
return(result);
}
}
// If we have an element that is not a property or an incomplete
// definition => interpret element as a type.
XamlResolver resolver = new XamlResolver(compilation);
int dotIndex = last.LocalName.IndexOf(".", StringComparison.Ordinal) + 1;
if (dotIndex < 1 || dotIndex == last.LocalName.Length)
{
rt = resolver.ResolveType(last.Namespace, last.LocalName.Trim('.'));
string contentPropertyName = GetContentPropertyName(rt.GetDefinition());
// If the type has a content property specified, use its type for completion.
if (!string.IsNullOrEmpty(contentPropertyName))
{
IProperty p = rt.GetProperties(m => m.Name == contentPropertyName).FirstOrDefault();
if (p != null)
{
rt = p.ReturnType;
}
}
}
else
{
string typeName = last.LocalName.Substring(0, dotIndex - 1);
string memberName = last.LocalName.Substring(dotIndex);
rt = resolver.ResolveType(last.Namespace, typeName);
IMember member = rt.GetMembers(m => m.Name == memberName).FirstOrDefault();
if (member != null)
{
rt = member.ReturnType;
}
}
}
bool parentAdded = false;
var utd = file.GetInnermostTypeDefinition(editor.Caret.Location);
ITypeDefinition currentTypeDef = null;
if (utd != null)
{
currentTypeDef = utd.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).GetDefinition();
}
MemberLookup memberLookup = new MemberLookup(currentTypeDef, compilation.MainAssembly);
IList <ITypeDefinition> possibleTypesInCollection = EmptyList <ITypeDefinition> .Instance;
if (rt != null && Extensions.IsListType(rt))
{
possibleTypesInCollection = rt.GetMethods(m => m.Parameters.Count == 1 && "Add".Equals(m.Name, StringComparison.Ordinal))
.Select(m => m.Parameters[0].Type.GetDefinition())
.Where(t => t != null)
.ToList();
}
var items = GetClassesFromContext(context);
foreach (var ns in items)
{
foreach (ITypeDefinition td in ns.Value)
{
if (td.Kind != TypeKind.Class && (!includeAbstract || td.Kind != TypeKind.Interface))
{
continue;
}
if (td.IsStatic || (!includeAbstract && td.IsAbstract) || td.IsDerivedFrom(KnownTypeCode.Attribute))
{
continue;
}
if (td.Kind == TypeKind.Class && !td.GetConstructors().Any(m => memberLookup.IsAccessible(m, false)))
{
continue;
}
if (possibleTypesInCollection.Count > 0 && !possibleTypesInCollection.Any(td.IsDerivedFrom))
{
continue;
}
string fullName = td.Name;
if (!string.IsNullOrEmpty(ns.Key))
{
fullName = ns.Key + ":" + fullName;
}
XamlCompletionItem item = new XamlCompletionItem(fullName, td);
parentAdded = parentAdded || (last != null && item.Text == last.Name);
result.Add(item);
}
}
// TODO reimplement this if it is really necessary.
// if (!parentAdded && last != null && !last.Name.Contains(".")) {
// IClass itemClass = cu.CreateType(last.Namespace, last.LocalName.Trim('.')).GetUnderlyingClass();
// if (itemClass != null)
// result.Add(new XamlCodeCompletionItem(itemClass, last.Prefix));
// }
return(result);
}
public override void VisitDocument(AXmlDocument document)
{
currentDocument = document;
AXmlElement rootElement = currentDocument.Children.OfType <AXmlElement>().FirstOrDefault();
if (rootElement != null)
{
string className = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "Class");
string modifier = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "ClassModifier");
if (className != null)
{
TypeDefinition = new DefaultUnresolvedTypeDefinition(className)
{
Kind = TypeKind.Class,
UnresolvedFile = file,
Accessibility = Accessibility.Public,
Region = new DomRegion(file.FileName, textDocument.GetLocation(rootElement.StartOffset), textDocument.GetLocation(rootElement.EndOffset))
};
TypeDefinition.Members.Add(
new DefaultUnresolvedMethod(TypeDefinition, "InitializeComponent")
{
Accessibility = Accessibility.Public,
ReturnType = KnownTypeReference.Void
});
TypeDefinition.Members.Add(
new DefaultUnresolvedField(TypeDefinition, "_contentLoaded")
{
Accessibility = Accessibility.Private,
ReturnType = KnownTypeReference.Boolean
});
var connectMember =
new DefaultUnresolvedMethod(TypeDefinition, "Connect")
{
Accessibility = Accessibility.Private,
ReturnType = KnownTypeReference.Void
};
connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Int32, "connectionId"));
connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Object, "target"));
TypeDefinition.Members.Add(connectMember);
connectMember.ExplicitInterfaceImplementations.Add(
new DefaultMemberReference(SymbolKind.Method, new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)), "Connect"));
var browsableAttribute = new DefaultUnresolvedAttribute(new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)));
browsableAttribute.PositionalArguments.Add(
new SimpleConstantValue(
new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)), System.ComponentModel.EditorBrowsableState.Never
));
connectMember.Attributes.Add(browsableAttribute);
TypeDefinition.BaseTypes.Add(CreateTypeReference(rootElement.Namespace, rootElement.LocalName));
TypeDefinition.BaseTypes.Add(new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)));
if (modifier != null)
{
TypeDefinition.Accessibility = ParseAccessibility(modifier);
}
}
}
base.VisitDocument(document);
}
static IReturnType TypeFromXmlNode(XamlCompilationUnit cu, AXmlElement element)
{
return(cu.CreateType(element.Namespace, element.LocalName));
}
/// <summary>
/// get the first xmlobject from baseNode by xpath. <br/>
/// if there are multiple objects in baseNode, <br/>
/// fill list argument. this function will fill this list with all xml objects<br/>
/// that have the path.<br/>
/// </summary>
/// <param name="baseNode">if you don't know root, call GetRoot(AXmlDocument xDoc) static method.</param>
/// <param name="xPath">seperator is '/'. ex>Command/Data</param>
/// <param name="list">if null, this function just return the first Node and end. but if not null, all reference will be inserted in this list</param>
/// <returns>the first XmlNode which has the path of xPath, formatted of AXmlObject</returns>
public static AXmlObject GetXmlObject(AXmlElement baseNode, String xPath, List <AXmlObject> list = null)
{
String firstNodeName = xPath; // '/'가 없는 문자열일 경우 그 자체가 이름..
String lastPath = "";
AXmlObject selectedObj = null;
AXmlObject firstSelected = null;
if (baseNode == null)
{
return(null);
}
if (xPath.Contains('/'))
{
firstNodeName = xPath.Substring(0, xPath.IndexOf("/"));
lastPath = xPath.Substring(xPath.IndexOf('/') + 1);
if (firstNodeName.Equals(baseNode.Name))
{
if (lastPath.Contains('/'))
{
firstNodeName = lastPath.Substring(0, lastPath.IndexOf("/"));
lastPath = lastPath.Substring(lastPath.IndexOf('/') + 1);
}
else
{
firstNodeName = lastPath;
lastPath = "";
}
}
}
if (lastPath.Length == 0 && baseNode.Name.ToLower().Equals(firstNodeName.ToLower()))
{
list.Add(baseNode);
return(baseNode);
}
else
{
foreach (AXmlObject obj in baseNode.Children)
{
if (obj is AXmlElement)
{
AXmlElement element = (obj as AXmlElement);
if (element.Name.Equals(firstNodeName))
{//첫 노드를 찾았으니 다음으로 넘어가야 한다.
if (lastPath.Length == 0)
{
selectedObj = element;
}
else
{
selectedObj = GetXmlObject(element, lastPath, list);
}
if (selectedObj != null)
{
if (list == null)
{
return(selectedObj);
}
else
{
if (firstSelected == null)
{
firstSelected = selectedObj;
}
list.Add(selectedObj);
}
}
}
}
else if (obj is AXmlAttribute && firstNodeName[0].Equals('@'))//Attribute일 경우, XPath의 첫글자는 @로 시작해야 한다.
{
AXmlAttribute attr = (obj as AXmlAttribute);
if (attr.Name.Equals(firstNodeName))
{//첫 노드를 찾았으니 다음으로 넘어가야 한다.
selectedObj = attr;
if (selectedObj != null)
{
if (list == null)
{
return(selectedObj);
}
else
{
if (firstSelected == null)
{
firstSelected = selectedObj;
}
list.Add(selectedObj);
}
}
}
}
}
}
return(firstSelected);
}
public void ActiveOnOffset(int textOffset)
{
SetCaretOffset(textOffset);
AXmlObject xmlObj = xDoc.GetChildAtOffset(textOffset);
backgroundRenderer.HighlightColor = Color.FromArgb(0x40, 0, 0, 0xFF);
ActiveObject = xmlObj;
_activeIndex = -1; //초기값..
if (xmlObj is AXmlText)
{
if (xmlObj.Parent != null && xmlObj.Parent is AXmlTag)
{
AXmlTag tag = xmlObj.Parent as AXmlTag;
if (tag.OpeningBracket.Equals("<!--"))//comment
{
ActiveComment = tag;
ActiveElement = null;
_activeIndex = GetIndex(tag, true);
}
else
{
ActiveComment = null;
}
}
else
{
ActiveComment = null;
}
}
else if (xmlObj is AXmlTag)
{
AXmlTag tag = xmlObj as AXmlTag;
if (tag.OpeningBracket.Equals("<!--"))//comment
{
ActiveComment = tag;
ActiveElement = null;
_activeIndex = GetIndex(tag, true);
}
else
{
ActiveComment = null;
}
}
else
{
ActiveComment = null;
}
if (ActiveComment == null)
{
ActiveElement = AXmlFinder.FindOwnerElement(xmlObj, true);
if (ActiveElement != null)
{
_activeIndex = GetIndex(ActiveElement, true);
}
}
if (xmlObj is AXmlAttribute)
{
ActiveAttribute = xmlObj as AXmlAttribute;
}
else if ((xmlObj is AXmlElement) == false && (xmlObj is AXmlTag))
{
ActiveAttribute = null;
}
else
{
ActiveAttribute = null;
}
if (ActiveComment != null)
{
backgroundRenderer.HighlightObjects = new AXmlObject[] { ActiveComment }
}
/// <summary>
/// find the element which has xmlObj as a child or grand x child.
/// </summary>
/// <param name="xmlObj">start point</param>
/// <param name="useItSelfIfElement">if start point is element, return this one</param>
/// <param name="elementName">find parent </param>
/// <returns>parent element which has xmlObj as a child or grand x child</returns>
public static AXmlElement FindOwnerElement(AXmlObject xmlObj, bool useItSelfIfElement = false, String elementName = null, bool ignoreCases = true)
{
if (useItSelfIfElement)
{
if (xmlObj is AXmlElement)
{
if (elementName == null)
{
return(xmlObj as AXmlElement);
}
else if (ignoreCases)
{
if ((xmlObj as AXmlElement).Name.ToLower().Equals(elementName.ToLower()))
{
return(xmlObj as AXmlElement);
}
}
else
{
if ((xmlObj as AXmlElement).Name.Equals(elementName))
{
return(xmlObj as AXmlElement);
}
}
}
}
AXmlObject temp = xmlObj.Parent;
if (temp == null)
{
return(null); //the end of node
}
if (elementName == null)
{
while (temp != null && (temp is AXmlElement) == false)
{
temp = temp.Parent;
}
}
else //there is parent name which will be found.
{
AXmlElement parent = null;
while (temp != null)
{
if (temp is AXmlElement)
{
if (ignoreCases)
{
if ((temp as AXmlElement).Name.ToLower().Equals(elementName.ToLower()))
{
parent = temp as AXmlElement;
break;
}
}
else
{
if ((temp as AXmlElement).Name.Equals(elementName))
{
parent = temp as AXmlElement;
break;
}
}
}
temp = temp.Parent;
}
return(parent);
}
if ((temp is AXmlElement) == false)
{
return(null);
}
else
{
return(temp as AXmlElement);
}
}
public static XamlContext ResolveContext(FileName fileName, ITextSource fileContent, int offset)
{
XamlFullParseInformation info = SD.ParserService.Parse(fileName, fileContent) as XamlFullParseInformation;
if (info == null)
{
throw new Exception("need full parse info!");
}
AXmlDocument document = info.Document;
AXmlObject currentData = document.GetChildAtOffset(offset);
string attributeName = string.Empty, attributeValue = string.Empty;
AttributeValue value = null;
bool isRoot = false;
bool wasAXmlElement = false;
int offsetFromValueStart = -1;
List <AXmlElement> ancestors = new List <AXmlElement>();
Dictionary <string, XamlNamespace> xmlns = new Dictionary <string, XamlNamespace>();
List <string> ignored = new List <string>();
string xamlNamespacePrefix = string.Empty;
var item = currentData;
AXmlElement root = null;
while (item != document)
{
if (item is AXmlElement)
{
AXmlElement element = item as AXmlElement;
ancestors.Add(element);
foreach (var attr in element.Attributes)
{
if (attr.IsNamespaceDeclaration)
{
string prefix = (attr.Name == "xmlns") ? "" : attr.LocalName;
if (!xmlns.ContainsKey(prefix))
{
xmlns.Add(prefix, new XamlNamespace(attr.Value));
}
}
if (attr.LocalName == "Ignorable" && attr.Namespace == XamlConst.MarkupCompatibilityNamespace)
{
ignored.AddRange(attr.Value.Split(' ', '\t'));
}
if (string.IsNullOrEmpty(xamlNamespacePrefix) && attr.Value == XamlConst.XamlNamespace)
{
xamlNamespacePrefix = attr.LocalName;
}
}
if (element.Parent is AXmlDocument)
{
root = element;
if (!wasAXmlElement)
{
isRoot = true;
}
}
wasAXmlElement = true;
}
item = item.Parent;
}
XamlContextDescription description = XamlContextDescription.None;
AXmlElement active = null;
AXmlElement parent = null;
if (currentData is AXmlAttribute)
{
AXmlAttribute a = currentData as AXmlAttribute;
int valueStartOffset = a.ValueSegment.Offset + 1;
attributeName = a.Name;
attributeValue = a.Value;
value = MarkupExtensionParser.ParseValue(attributeValue);
if (offset >= valueStartOffset && (offset < a.EndOffset || // if length is < 2 one quote is missing
(a.ValueSegment.Length <= 1 && offset <= a.EndOffset)))
{
offsetFromValueStart = offset - valueStartOffset;
description = XamlContextDescription.InAttributeValue;
if (value != null && !value.IsString)
{
description = XamlContextDescription.InMarkupExtension;
}
if (attributeValue.StartsWith("{}", StringComparison.Ordinal) && attributeValue.Length > 2)
{
description = XamlContextDescription.InAttributeValue;
}
}
else
{
description = XamlContextDescription.InTag;
}
active = a.ParentElement;
}
else if (currentData is AXmlTag)
{
AXmlTag tag = currentData as AXmlTag;
if (tag.IsStartOrEmptyTag || tag.IsEndTag)
{
if (tag.NameSegment.EndOffset < offset)
{
description = XamlContextDescription.InTag;
}
else
{
description = XamlContextDescription.AtTag;
}
}
else if (tag.IsComment)
{
description = XamlContextDescription.InComment;
}
else if (tag.IsCData)
{
description = XamlContextDescription.InCData;
}
active = tag.Parent as AXmlElement;
}
if (active != ancestors.FirstOrDefault())
{
parent = ancestors.FirstOrDefault();
}
else
{
parent = ancestors.Skip(1).FirstOrDefault();
}
if (active == null)
{
active = parent;
}
var xAttribute = currentData as AXmlAttribute;
var context = new XamlContext()
{
Description = description,
ActiveElement = active,
ParentElement = parent,
RootElement = root,
Ancestors = ancestors.AsReadOnly(),
Attribute = xAttribute,
InRoot = isRoot,
AttributeValue = value,
RawAttributeValue = attributeValue,
ValueStartOffset = offsetFromValueStart,
XmlnsDefinitions = xmlns,
ParseInformation = info,
IgnoredXmlns = ignored.AsReadOnly(),
XamlNamespacePrefix = xamlNamespacePrefix
};
return(context);
}
public static ElementWrapper ToWrapper(this AXmlElement element)
{
return(new ElementWrapper(element));
}
public static QualifiedNameWithLocation ToQualifiedName(this AXmlElement thisValue)
{
return(new QualifiedNameWithLocation(thisValue.LocalName, thisValue.Namespace, thisValue.Prefix, thisValue.StartOffset));
}
