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 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);
}
