public void ContextInTagDescriptionTest2()
{
string xaml = @"<Window x:Class='Vokabeltrainer.Window1'
xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
Title=''>
<Grid>
<StackPanel>
<RadioButton
</StackPanel>
</Grid>
</Window>";
int offset = @"<Window x:Class='Vokabeltrainer.Window1'
xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
Title=''>
<Grid>
<StackPanel>
<RadioButton " .Length;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(XamlContextDescription.InTag, context.Description);
}
public void ContextAtTagDescriptionTest4()
{
string xaml = "<Grid>\n\t<\n</Grid>";
int offset = "<Grid>\n\t<".Length;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(XamlContextDescription.AtTag, context.Description);
}
public void ContextAtTagDescriptionTest3()
{
string xaml = File.ReadAllText("Test4.xaml");
int offset = 413;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(XamlContextDescription.AtTag, context.Description);
}
public void ElementNameWithDotTest1()
{
string xaml = "<Grid>\n\t<Grid.ColumnDefinitions />\n</Grid>";
int offset = "<Grid>\n".Length + 12;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual("Grid.ColumnDefinitions", context.ActiveElement.Name);
}
public void ContextInTagDescriptionTest()
{
string xaml = "<Grid>\n\t<CheckBox x:Name=\"asdf\" Background=\"Aqua\" Content=\"{x:Static Cursors.Arrow}\" />\n</Grid>";
int offset = "<Grid>\n".Length + 26;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(XamlContextDescription.InTag, context.Description);
}
public void RootElementTest()
{
string xaml = File.ReadAllText("Test1.xaml");
int offset = 31;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual("Window", context.ActiveElement.Name);
Assert.AreEqual(null, context.ParentElement);
}
public void ParentElementTestSimple2()
{
string xaml = File.ReadAllText("Test4.xaml");
int offset = 413;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual("Grid", context.ActiveElement.Name);
Assert.AreEqual("Grid", context.ParentElement.Name);
}
public void ContextInAttributeValueTest3()
{
string xaml = "<Test attr=\"Test />";
int offset = "<Test attr=\"".Length;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(XamlContextDescription.InAttributeValue, context.Description);
}
public void ContextInMarkupExtensionTest2()
{
string xaml = "<Test attr=\"{}{Test}\" />";
int offset = "<Test attr=\"{}{Te".Length;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(XamlContextDescription.InAttributeValue, context.Description);
}
public void IgnoredXmlnsTest1()
{
string xaml = File.ReadAllText("Test2.xaml");
int offset = 447;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
Assert.AreEqual(1, context.IgnoredXmlns.Count);
Assert.AreEqual("d", context.IgnoredXmlns[0]);
}
static void DoTriggerCompletion(XamlCompletionContext context, XamlCompletionItemList completionList)
{
bool isExplicit;
AttributeValue value = MarkupExtensionParser.ParseValue(CompletionDataHelper.LookForTargetTypeValue(context, out isExplicit, "Trigger") ?? string.Empty);
IReturnType typeName = null;
string typeNameString = null;
if (!value.IsString)
{
typeNameString = CompletionDataHelper.GetTypeNameFromTypeExtension(value.ExtensionValue, context);
typeName = CompletionDataHelper.ResolveType(typeNameString, context);
}
else
{
typeNameString = value.StringValue;
typeName = CompletionDataHelper.ResolveType(value.StringValue, context);
}
if (typeName != null)
{
switch (context.Attribute.Name)
{
case "Value":
AttributeValue propType = MarkupExtensionParser.ParseValue(context.ActiveElement.GetAttributeValue("Property") ?? "");
if (!propType.IsString)
{
break;
}
string name = propType.StringValue;
if (!name.Contains("."))
{
name = typeNameString + "." + name;
}
context.Description = XamlContextDescription.AtTag;
var member = XamlResolver.Resolve(name, context) as MemberResolveResult;
if (member == null || member.ResolvedMember == null)
{
break;
}
completionList.Items.AddRange(
CompletionDataHelper.MemberCompletion(context, member.ResolvedMember.ReturnType, string.Empty)
);
break;
}
}
}
static IMember Resolve(XAttribute attribute, ITextEditor editor)
{
XamlContext context = CompletionDataHelper.ResolveCompletionContext(editor, default(char), editor.Document.PositionToOffset(attribute.GetLineNumber(), attribute.GetLinePosition()));
string prefix = context.XmlnsDefinitions.GetKeyByValue(attribute.Name.NamespaceName);
if (!string.IsNullOrEmpty(prefix))
{
prefix += ":";
}
var mrr = XamlResolver.Resolve(prefix + attribute.Name.LocalName, context) as MemberResolveResult;
if (mrr != null)
{
return(mrr.ResolvedMember);
}
return(null);
}
public void AncestorDetectionTest1()
{
string xaml = File.ReadAllText("Test5.xaml");
int offset = 881;
XamlContext context = CompletionDataHelper.ResolveContext(xaml, "", offset);
string[] ancestors = new string[] {
"DoubleAnimation", "Storyboard",
"BeginStoryboard", "EventTrigger",
"Button.Triggers", "Button",
"Grid", "Window"
};
Assert.AreEqual("DoubleAnimation", context.ActiveElement.Name);
Assert.AreEqual("Storyboard", context.ParentElement.Name);
Assert.AreEqual(8, context.Ancestors.Count);
Assert.AreEqual(ancestors, context.Ancestors.Select(item => item.Name).ToArray());
}
static bool DoMarkupExtensionCompletion(XamlCompletionContext context)
{
if (context.Description == XamlContextDescription.InMarkupExtension && context.AttributeValue != null && !context.AttributeValue.IsString)
{
if (!XamlBindingOptions.UseExtensionCompletion)
{
return(false);
}
XamlCompletionItemList completionList = CompletionDataHelper.CreateMarkupExtensionCompletion(context) as XamlCompletionItemList;
string word = context.Editor.GetWordBeforeCaretExtended();
if (context.PressedKey != '.' && context.PressedKey != '=' && !word.EndsWith(".") && completionList.PreselectionLength == 0)
{
completionList.PreselectionLength = word.Length;
}
var insightList = CompletionDataHelper.CreateMarkupExtensionInsight(context);
context.Editor.ShowInsightWindow(insightList);
context.Editor.ShowCompletionWindow(completionList);
return(completionList.Items.Any() || insightList.Any());
}
return(false);
}
public ResolveResult Resolve(ExpressionResult expressionResult, ParseInformation parseInfo, string fileContent)
{
if (parseInfo == null || (string.IsNullOrEmpty(fileContent) && !(expressionResult.Context is XamlContext)))
{
return(null);
}
this.resolveExpression = expressionResult.Expression;
this.caretLine = expressionResult.Region.BeginLine;
this.caretColumn = expressionResult.Region.BeginColumn;
this.callingClass = parseInfo.CompilationUnit.GetInnermostClass(caretLine, caretColumn);
this.context = expressionResult.Context as XamlContext ?? CompletionDataHelper.ResolveContext(fileContent, parseInfo.CompilationUnit.FileName, Utils.GetOffsetFromFilePos(fileContent, caretLine, caretColumn));
switch (this.context.Description)
{
case XamlContextDescription.AtTag:
case XamlContextDescription.None:
return(ResolveElementName(resolveExpression));
case XamlContextDescription.InTag:
return(ResolveAttribute(resolveExpression) ?? ResolveElementName(resolveExpression));
case XamlContextDescription.InAttributeValue:
MemberResolveResult mrr = ResolveAttribute(context.Attribute.Name);
if (mrr != null)
{
var rr = ResolveAttributeValue(mrr.ResolvedMember, resolveExpression) ?? mrr;
return(rr);
}
break;
case XamlContextDescription.InMarkupExtension:
return(ResolveMarkupExtension(resolveExpression));
}
return(null);
}
static void DoSetterAndEventSetterCompletion(XamlCompletionContext context, XamlCompletionItemList completionList)
{
bool isExplicit;
string element = context.ParentElement.Name.EndsWith("Trigger") ? "Trigger" : context.ParentElement.Name;
AttributeValue value = MarkupExtensionParser.ParseValue(CompletionDataHelper.LookForTargetTypeValue(context, out isExplicit, element) ?? string.Empty);
IReturnType typeName = null;
string typeNameString = null;
if (!value.IsString)
{
typeNameString = CompletionDataHelper.GetTypeNameFromTypeExtension(value.ExtensionValue, context);
typeName = CompletionDataHelper.ResolveType(typeNameString, context);
}
else
{
typeNameString = value.StringValue;
typeName = CompletionDataHelper.ResolveType(value.StringValue, context);
}
if (typeName != null)
{
switch (context.Attribute.Name)
{
case "Value":
AttributeValue propType = MarkupExtensionParser.ParseValue(context.ActiveElement.GetAttributeValue("Property") ?? "");
if (!propType.IsString)
{
break;
}
context.Description = XamlContextDescription.AtTag;
string name = propType.StringValue;
if (!name.Contains("."))
{
name = typeNameString + "." + name;
}
var member = XamlResolver.Resolve(name, context) as MemberResolveResult;
if (member == null || member.ResolvedMember == null)
{
break;
}
completionList.Items.AddRange(
CompletionDataHelper.MemberCompletion(context, member.ResolvedMember.ReturnType, string.Empty)
);
break;
case "Property":
completionList.Items.AddRange(
typeName.GetProperties()
.Where(p => p.IsPublic && p.CanSet)
.Select(prop => new XamlCodeCompletionItem(prop))
);
break;
case "Event":
completionList.Items.AddRange(
typeName.GetEvents()
.Where(e => e.IsPublic)
.Select(evt => new XamlCodeCompletionItem(evt))
);
break;
case "Handler":
var loc3 = context.Editor.Document.OffsetToPosition(XmlParser.GetActiveElementStartIndex(context.Editor.Document.Text, context.Editor.Caret.Offset));
AttributeValue evtType = MarkupExtensionParser.ParseValue(context.ActiveElement.GetAttributeValue("Event") ?? "");
if (!evtType.IsString)
{
break;
}
string evtName = evtType.StringValue;
if (!evtName.Contains("."))
{
evtName = typeNameString + "." + evtName;
}
var evtMember = XamlResolver.Resolve(evtName, context) as MemberResolveResult;
if (evtMember == null || evtMember.ResolvedMember == null || !(evtMember.ResolvedMember is IEvent) || evtMember.ResolvedMember.ReturnType == null)
{
break;
}
IClass c = (evtMember.ResolvedMember as IEvent).ReturnType.GetUnderlyingClass();
if (c == null)
{
break;
}
IMethod invoker = c.Methods.FirstOrDefault(m => m.Name == "Invoke");
if (invoker == null)
{
break;
}
completionList.Items.AddRange(
CompletionDataHelper.AddMatchingEventHandlers(context, invoker).Add(new NewEventCompletionItem(evtMember.ResolvedMember as IEvent, typeName.Name))
);
break;
}
}
}
IEnumerable <HighlightingInfo> GetInfo()
{
int index = -1;
XamlContext context = null;
do
{
if (index + 1 >= lineText.Length)
{
break;
}
index = lineText.IndexOfAny(index + 1, '=', '.');
if (index > -1)
{
context = CompletionDataHelper.ResolveContext(snapshot, fileName, offset + index);
if (context.ActiveElement == null || context.InAttributeValueOrMarkupExtension || context.InCommentOrCData)
{
continue;
}
string propertyName;
string token;
int startIndex;
switch (context.Description)
{
case XamlContextDescription.AtTag:
token = context.ActiveElement.Name;
int propertyNameIndex = token.IndexOf('.');
if (propertyNameIndex == -1)
{
continue;
}
propertyName = token.Substring(propertyNameIndex + 1);
startIndex = lineText.IndexOf(propertyName, index, StringComparison.Ordinal);
break;
case XamlContextDescription.InTag:
if (lineText[index] == '.' || context.Attribute == null)
{
continue;
}
token = propertyName = context.Attribute.Name;
startIndex = lineText.LastIndexOf(propertyName, index, StringComparison.Ordinal);
break;
default:
continue;
}
if (startIndex > -1)
{
yield return(new HighlightingInfo(token, startIndex, startIndex + propertyName.Length, offset, context));
}
}
} while (index > -1);
}
public bool CtrlSpace(ITextEditor editor)
{
XamlCompletionContext context = CompletionDataHelper.ResolveCompletionContext(editor, ' ');
context.Forced = trackForced;
if (context.Description == XamlContextDescription.InComment || context.Description == XamlContextDescription.InCData)
{
return(false);
}
if (context.ActiveElement != null)
{
if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset) && context.Description != XamlContextDescription.InAttributeValue)
{
XamlCompletionItemList list = CompletionDataHelper.CreateListForContext(context);
string starter = editor.GetWordBeforeCaretExtended().TrimStart('/');
if (context.Description != XamlContextDescription.None && !string.IsNullOrEmpty(starter))
{
if (starter.Contains("."))
{
list.PreselectionLength = starter.Length - starter.IndexOf('.') - 1;
}
else
{
list.PreselectionLength = starter.Length;
}
}
editor.ShowCompletionWindow(list);
return(true);
}
else
{
// DO NOT USE CompletionDataHelper.CreateListForContext here!!! results in endless recursion!!!!
if (context.Attribute != null)
{
if (!DoMarkupExtensionCompletion(context))
{
var completionList = new XamlCompletionItemList(context);
completionList.PreselectionLength = editor.GetWordBeforeCaretExtended().Length;
if ((context.ActiveElement.Name == "Setter" || context.ActiveElement.Name == "EventSetter") &&
(context.Attribute.Name == "Property" || context.Attribute.Name == "Value"))
{
DoSetterAndEventSetterCompletion(context, completionList);
}
else if ((context.ActiveElement.Name.EndsWith("Trigger") || context.ActiveElement.Name == "Condition") && context.Attribute.Name == "Value")
{
DoTriggerCompletion(context, completionList);
}
else
{
if (context.Attribute.Name == "xml:space")
{
completionList.Items.AddRange(new[] { new SpecialCompletionItem("preserve"),
new SpecialCompletionItem("default") });
}
var mrr = XamlResolver.Resolve(context.Attribute.Name, context) as MemberResolveResult;
if (mrr != null && mrr.ResolvedType != null)
{
completionList.Items.AddRange(CompletionDataHelper.MemberCompletion(context, mrr.ResolvedType, string.Empty));
editor.ShowInsightWindow(CompletionDataHelper.MemberInsight(mrr));
if (mrr.ResolvedType.FullyQualifiedName == "System.Windows.PropertyPath")
{
string start = editor.GetWordBeforeCaretExtended();
int index = start.LastIndexOfAny(PropertyPathTokenizer.ControlChars);
if (index + 1 < start.Length)
{
start = start.Substring(index + 1);
}
else
{
start = "";
}
completionList.PreselectionLength = start.Length;
}
else if (mrr.ResolvedType.FullyQualifiedName == "System.Windows.Media.FontFamily")
{
string text = context.ValueStartOffset > -1 ? context.RawAttributeValue.Substring(0, Math.Min(context.ValueStartOffset, context.RawAttributeValue.Length)) : "";
int lastComma = text.LastIndexOf(',');
completionList.PreselectionLength = lastComma == -1 ? context.ValueStartOffset : context.ValueStartOffset - lastComma - 1;
}
}
}
completionList.SortItems();
if (context.Attribute.Prefix.Equals("xmlns", StringComparison.OrdinalIgnoreCase) ||
context.Attribute.Name.Equals("xmlns", StringComparison.OrdinalIgnoreCase))
{
completionList.Items.AddRange(CompletionDataHelper.CreateListForXmlnsCompletion(context.ProjectContent));
}
ICompletionListWindow window = editor.ShowCompletionWindow(completionList);
if ((context.Attribute.Prefix.Equals("xmlns", StringComparison.OrdinalIgnoreCase) ||
context.Attribute.Name.Equals("xmlns", StringComparison.OrdinalIgnoreCase)) && window != null)
{
window.Width = 400;
}
return(completionList.Items.Any());
}
return(true);
}
}
}
return(false);
}
public CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
{
XamlCompletionContext context = CompletionDataHelper.ResolveCompletionContext(editor, ch);
XamlCompletionItemList list;
if (context.Description == XamlContextDescription.InComment || context.Description == XamlContextDescription.InCData)
{
return(CodeCompletionKeyPressResult.None);
}
switch (ch)
{
case '<':
context.Description = (context.Description == XamlContextDescription.None) ? XamlContextDescription.AtTag : context.Description;
list = CompletionDataHelper.CreateListForContext(context);
editor.ShowCompletionWindow(list);
return(CodeCompletionKeyPressResult.Completed);
case '>':
return(CodeCompletionKeyPressResult.None);
case '\'':
case '"':
if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset))
{
// count all " or ' chars before the next > char
int search = editor.Caret.Offset + 1;
int endMarkerCount = 1;
char curCh = editor.Document.GetCharAt(search);
while (search < editor.Document.TextLength - 1 && curCh != '>')
{
if (curCh == ch)
{
endMarkerCount++;
}
search++;
curCh = editor.Document.GetCharAt(search);
}
// if the count is odd we need to add an additional " or ' char
if (endMarkerCount % 2 != 0)
{
editor.Document.Insert(editor.Caret.Offset, ch.ToString());
editor.Caret.Offset--;
this.CtrlSpace(editor);
return(CodeCompletionKeyPressResult.Completed);
}
}
break;
case '{': // starting point for Markup Extension Completion
if (context.Attribute != null &&
XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset) &&
!(context.RawAttributeValue.StartsWith("{}", StringComparison.OrdinalIgnoreCase) && context.RawAttributeValue.Length != 2))
{
if (editor.SelectionLength != 0)
{
editor.Document.Remove(editor.SelectionStart, editor.SelectionLength);
}
editor.Document.Insert(editor.Caret.Offset, "{}");
editor.Caret.Offset--;
this.CtrlSpace(editor);
return(CodeCompletionKeyPressResult.EatKey);
}
break;
case '.':
switch (context.Description)
{
case XamlContextDescription.AtTag:
case XamlContextDescription.InTag:
if (context.ActiveElement != null && !XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset))
{
list = CompletionDataHelper.CreateListForContext(context);
editor.ShowCompletionWindow(list);
return(CodeCompletionKeyPressResult.Completed);
}
break;
case XamlContextDescription.InMarkupExtension:
if (DoMarkupExtensionCompletion(context))
{
return(CodeCompletionKeyPressResult.Completed);
}
break;
case XamlContextDescription.InAttributeValue:
if (editor.SelectionLength != 0)
{
editor.Document.Remove(editor.SelectionStart, editor.SelectionLength);
}
editor.Document.Insert(editor.Caret.Offset, ".");
this.CtrlSpace(editor);
return(CodeCompletionKeyPressResult.EatKey);
}
break;
case '(':
case '[':
if (context.Description == XamlContextDescription.InAttributeValue)
{
if (editor.SelectionLength != 0)
{
editor.Document.Remove(editor.SelectionStart, editor.SelectionLength);
}
if (ch == '(')
{
editor.Document.Insert(editor.Caret.Offset, "()");
}
if (ch == '[')
{
editor.Document.Insert(editor.Caret.Offset, "[]");
}
editor.Caret.Offset--;
this.CtrlSpace(editor);
return(CodeCompletionKeyPressResult.EatKey);
}
break;
case ':':
if (context.ActiveElement != null && XmlParser.GetQualifiedAttributeNameAtIndex(editor.Document.Text, editor.Caret.Offset) == null)
{
if (context.Attribute != null && !context.Attribute.Name.StartsWith("xmlns", StringComparison.OrdinalIgnoreCase))
{
list = CompletionDataHelper.CreateListForContext(context);
list.PreselectionLength = editor.GetWordBeforeCaretExtended().Length;
editor.ShowCompletionWindow(list);
return(CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion);
}
}
break;
case '/': // ignore '/' when trying to type '/>'
return(CodeCompletionKeyPressResult.None);
case '=':
if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset))
{
int searchOffset = editor.Caret.Offset;
if (editor.SelectionLength != 0)
{
editor.Document.Remove(editor.SelectionStart, editor.SelectionLength);
}
while (searchOffset < editor.Document.TextLength - 1)
{
searchOffset++;
if (!char.IsWhiteSpace(editor.Document.GetCharAt(searchOffset)))
{
break;
}
}
if (searchOffset >= editor.Document.TextLength || editor.Document.GetCharAt(searchOffset) != '"')
{
editor.Document.Insert(editor.Caret.Offset, "=\"\"");
editor.Caret.Offset--;
}
else
{
editor.Document.Insert(editor.Caret.Offset, "=");
editor.Caret.Offset++;
}
this.CtrlSpace(editor);
return(CodeCompletionKeyPressResult.EatKey);
}
else
{
DoMarkupExtensionCompletion(context);
return(CodeCompletionKeyPressResult.Completed);
}
default:
if (context.Description != XamlContextDescription.None && !char.IsWhiteSpace(ch))
{
string starter = editor.GetWordBeforeCaretExtended();
if (!string.IsNullOrEmpty(starter))
{
return(CodeCompletionKeyPressResult.None);
}
trackForced = false;
string attributeName = (context.Attribute != null) ? context.Attribute.Name : string.Empty;
if (!attributeName.StartsWith("xmlns", StringComparison.OrdinalIgnoreCase))
{
return(this.CtrlSpace(editor)
? CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion
: CodeCompletionKeyPressResult.None);
}
trackForced = true;
return(CodeCompletionKeyPressResult.None);
}
break;
}
return(CodeCompletionKeyPressResult.None);
}
private static IEnumerable <object[]> GetSnippetCompletionData() => CompletionDataHelper.GetSnippetCompletionData();
public override void Complete(CompletionContext context, ICompletionItem item)
{
using (context.Editor.Document.OpenUndoGroup()) {
base.Complete(context, item);
XamlCompletionContext xamlContext = CompletionDataHelper.ResolveCompletionContext(context.Editor, context.CompletionChar);
if (xamlContext.Description == XamlContextDescription.None && (context.StartOffset <= 0 || context.Editor.Document.GetCharAt(context.StartOffset - 1) != '<'))
{
context.Editor.Document.Insert(context.StartOffset, "<");
context.EndOffset++;
}
if (item is XamlCodeCompletionItem)
{
XamlCodeCompletionItem cItem = item as XamlCodeCompletionItem;
if (cItem.Entity is IProperty || cItem.Entity is IEvent)
{
if (xamlContext.Description == XamlContextDescription.InTag)
{
context.Editor.Document.Insert(context.EndOffset, "=\"\"");
context.CompletionCharHandled = context.CompletionChar == '=';
context.Editor.Caret.Offset--;
new XamlCodeCompletionBinding().CtrlSpace(context.Editor);
}
else if (xamlContext.Description == XamlContextDescription.InMarkupExtension && !string.IsNullOrEmpty(xamlContext.RawAttributeValue))
{
string valuePart = xamlContext.RawAttributeValue.Substring(0, xamlContext.ValueStartOffset);
AttributeValue value = MarkupExtensionParser.ParseValue(valuePart);
if (value != null && !value.IsString)
{
var markup = Utils.GetMarkupExtensionAtPosition(value.ExtensionValue, context.Editor.Caret.Offset);
if (markup.NamedArguments.Count > 0 || markup.PositionalArguments.Count > 0)
{
int oldOffset = context.Editor.Caret.Offset;
context.Editor.Caret.Offset = context.StartOffset;
string word = context.Editor.GetWordBeforeCaret().TrimEnd();
int spaces = CountWhiteSpacesAtEnd(context.Editor.GetWordBeforeCaret());
int typeNameStart = markup.ExtensionType.IndexOf(':') + 1;
if (!(word == "." || word == "," || word == ":") && markup.ExtensionType.Substring(typeNameStart, markup.ExtensionType.Length - typeNameStart) != word)
{
context.Editor.Document.Replace(context.Editor.Caret.Offset - spaces, spaces, ", ");
oldOffset += (2 - spaces);
}
context.Editor.Caret.Offset = oldOffset;
}
}
if (cItem.Text.EndsWith("=", StringComparison.OrdinalIgnoreCase))
{
new XamlCodeCompletionBinding().CtrlSpace(context.Editor);
}
}
}
}
if (item is NewEventCompletionItem)
{
NewEventCompletionItem eventItem = item as NewEventCompletionItem;
int discriminator;
if (CreateEventHandlerCode(context, eventItem, out discriminator))
{
if (discriminator > 0)
{
context.Editor.Document.Insert(context.EndOffset, discriminator.ToString());
}
}
}
if (item is XmlnsCompletionItem)
{
context.Editor.Caret.Offset++;
}
if (item is XamlCompletionItem && xamlContext.Description == XamlContextDescription.InTag)
{
context.Editor.Document.Insert(context.EndOffset, "=\"\"");
context.Editor.Caret.Offset--;
new XamlCodeCompletionBinding().CtrlSpace(context.Editor);
}
switch (item.Text)
{
case "![CDATA[":
context.Editor.Document.Insert(context.Editor.Caret.Offset, "]]>");
context.Editor.Caret.Offset -= 3;
break;
case "?":
context.Editor.Document.Insert(context.Editor.Caret.Offset, "?>");
context.Editor.Caret.Offset -= 2;
break;
case "!--":
context.Editor.Document.Insert(context.Editor.Caret.Offset, " -->");
context.Editor.Caret.Offset -= 4;
break;
}
if (item.Text.StartsWith("/", StringComparison.OrdinalIgnoreCase))
{
context.Editor.Document.Insert(context.EndOffset, ">");
context.CompletionCharHandled = context.CompletionChar == '>';
context.Editor.Caret.Offset++;
}
}
}
