public bool IsTemplateKnown()
{
string shortcut = CodeTemplate.GetTemplateShortcutBeforeCaret(EditorExtension.Editor);
bool result = false;
foreach (CodeTemplate template in CodeTemplateService.GetCodeTemplates(Document.MimeType))
{
if (template.Shortcut == shortcut)
{
result = true;
}
else if (template.Shortcut.StartsWith(shortcut))
{
result = false;
break;
}
}
return(result);
}
public bool IsTemplateKnown(ExtensibleTextEditor instance)
{
string shortcut = CodeTemplate.GetTemplateShortcutBeforeCaret(EditorExtension.Editor);
bool result = false;
foreach (CodeTemplate template in CodeTemplateService.GetCodeTemplatesAsync(EditorExtension.Editor).WaitAndGetResult(CancellationToken.None))
{
if (template.Shortcut == shortcut)
{
result = true;
}
else if (template.Shortcut.StartsWith(shortcut))
{
result = false;
break;
}
}
return(result);
}
public bool IsTemplateKnown()
{
string word = GetWordBeforeCaret();
bool result = false;
foreach (CodeTemplate template in CodeTemplateService.GetCodeTemplates(Document.MimeType))
{
if (template.Shortcut == word)
{
result = true;
}
else if (template.Shortcut.StartsWith(word))
{
result = false;
break;
}
}
return(result);
}
public IEnumerable<ExpansionTemplate> EnumerateExpansions (IContentType contentType, bool shortcutOnly, string[] snippetTypes, bool includeNullType, bool includeDuplicates)
{
List<ExpansionTemplate> templates = null;
lock (expansionTemplates) {
if (expansionTemplates.TryGetValue (contentType, out templates))
return templates;
}
templates = new List<ExpansionTemplate> ();
foreach (var codeTemplate in CodeTemplateService.GetCodeTemplates (
IdeServices.DesktopService.GetMimeTypeForContentType (contentType))) {
try {
templates.Add (Convert (codeTemplate));
} catch (Exception e) {
LoggingService.LogError ("Exception converting Snippet to VS Expansion Template", e);
}
}
if (Directory.Exists (UserSnippetsPath)) {
try {
foreach (var snippetFile in Directory.EnumerateFiles (UserSnippetsPath, "*.snippet")) {
try {
templates.Add (new ExpansionTemplate (snippetFile));
} catch (Exception parseException) {
LoggingService.LogError (
$"Unable to parse VS Expansion template: {snippetFile}",
parseException);
}
}
} catch (Exception enumerateException) {
LoggingService.LogError (
$"Exception enumerating snippets directory: {UserSnippetsPath}",
enumerateException);
}
}
lock (expansionTemplates)
expansionTemplates[contentType] = templates;
return templates;
}
public System.Collections.Generic.IEnumerable <ItemToolboxNode> GetDynamicItems(IToolboxConsumer consumer)
{
MonoDevelop.Ide.Gui.Content.IExtensibleTextEditor editor
= consumer as MonoDevelop.Ide.Gui.Content.IExtensibleTextEditor;
if (editor != null)
{
foreach (CodeTemplate ct in CodeTemplateService.GetCodeTemplatesForFile(editor.Name))
{
if (ct.CodeTemplateContext != CodeTemplateContext.Standard)
{
continue;
}
yield return(new TemplateToolboxNode(ct)
{
Category = category,
Icon = ImageService.GetPixbuf("md-template", Gtk.IconSize.Menu)
});
}
}
yield break;
}
public System.Collections.Generic.IEnumerable <ItemToolboxNode> GetDynamicItems(IToolboxConsumer consumer)
{
var editor = consumer as IReadonlyTextDocument;
if (editor != null)
{
foreach (CodeTemplate ct in CodeTemplateService.GetCodeTemplatesForFile(editor.FileName))
{
if (ct.CodeTemplateContext != CodeTemplateContext.Standard)
{
continue;
}
yield return(new TemplateToolboxNode(ct)
{
Category = category,
Icon = ImageService.GetIcon("md-template", Gtk.IconSize.Menu)
});
}
}
yield break;
}
public bool DoInsertTemplate()
{
string shortcut = CodeTemplate.GetTemplateShortcutBeforeCaret(EditorExtension.Editor);
foreach (CodeTemplate template in CodeTemplateService.GetCodeTemplatesAsync(EditorExtension.Editor).WaitAndGetResult(CancellationToken.None))
{
if (template.Shortcut == shortcut)
{
var doc = view.WorkbenchWindow?.Document ?? IdeApp.Workbench.ActiveDocument;
if (doc != null)
{
InsertTemplate(template, doc.Editor, doc);
}
else
{
LoggingService.LogError("DoInsertTemplate(): Can't find valid document");
}
return(true);
}
}
return(false);
}
// handles the details of inserting a code template
// returns true if it was inserted
public bool InsertTemplate()
{
if (AutoInsertTemplates)
{
string word = GetWordBeforeCaret();
if (word != null)
{
CodeTemplateGroup templateGroup = CodeTemplateService.GetTemplateGroupPerFilename(ParentEditor.DisplayBinding.ContentName);
if (templateGroup != null)
{
foreach (CodeTemplate template in templateGroup.Templates)
{
if (template.Shortcut == word)
{
InsertTemplate(template);
return(true);
}
}
}
}
}
return(false);
}
public virtual ICompletionDataList ShowCodeSurroundingsCommand(CodeCompletionContext completionContext)
{
CompletionDataList list = new CompletionDataList();
list.CompletionSelectionMode = CompletionSelectionMode.OwnTextField;
var templateWidget = Document.GetContent <ICodeTemplateContextProvider> ();
CodeTemplateContext ctx = CodeTemplateContext.Standard;
if (templateWidget != null)
{
ctx = templateWidget.GetCodeTemplateContext();
}
foreach (CodeTemplate template in CodeTemplateService.GetCodeTemplatesForFile(Document.FileName))
{
if ((template.CodeTemplateType & CodeTemplateType.SurroundsWith) == CodeTemplateType.SurroundsWith)
{
if (ctx == template.CodeTemplateContext)
{
list.Add(new CodeTemplateCompletionData(Document, template));
}
}
}
return(list);
}
public override async Task <ICompletionDataList> HandleCodeCompletionAsync(CodeCompletionContext completionContext, CompletionTriggerInfo triggerInfo, CancellationToken token)
{
if (inactive)
{
return(await base.HandleCodeCompletionAsync(completionContext, triggerInfo, token));
}
if (Editor.MimeType == "text/plain")
{
return(null);
}
if (!IdeApp.Preferences.EnableAutoCodeCompletion)
{
return(null);
}
if (triggerInfo.CompletionTriggerReason != CompletionTriggerReason.CharTyped)
{
return(null);
}
char completionChar = triggerInfo.TriggerCharacter.Value;
int triggerWordLength = 0;
if (char.IsLetterOrDigit(completionChar) || completionChar == '_')
{
if (completionContext.TriggerOffset > 1 && char.IsLetterOrDigit(Editor.GetCharAt(completionContext.TriggerOffset - 2)))
{
return(null);
}
triggerWordLength = 1;
}
else
{
return(null);
}
var result = new CompletionDataList();
result.TriggerWordLength = triggerWordLength;
result.AutoSelect = false;
result.AutoCompleteEmptyMatch = false;
result.AutoCompleteUniqueMatch = false;
result.AutoCompleteEmptyMatchOnCurlyBrace = false;
foreach (var ct in await CodeTemplateService.GetCodeTemplatesAsync(Editor, token))
{
if (string.IsNullOrEmpty(ct.Shortcut) || ct.CodeTemplateContext != CodeTemplateContext.Standard)
{
continue;
}
result.Add(new CodeTemplateCompletionData(this, ct));
}
foreach (var word in await GetAllWords(Editor.CreateSnapshot(), Editor.CaretOffset))
{
result.Add(new CompletionData(word));
}
if (result.Count == 0)
{
return(null);
}
return(result);
}
public CSharpTextEditorCompletion.CompletionDataCollector AddAccessibleCodeCompletionData(ExpressionContext context, CSharpTextEditorCompletion.CompletionDataCollector col)
{
if (context != ExpressionContext.Global && context != ExpressionContext.TypeName)
{
AddContentsFromClassAndMembers(context, col);
if (lookupTableVisitor != null && lookupTableVisitor.Variables != null)
{
// int callingMemberline = CallingMember != null ? CallingMember.Location.Line : 0;
// local variables could be outside members (LINQ initializers)
foreach (KeyValuePair <string, List <LocalLookupVariable> > pair in lookupTableVisitor.Variables)
{
if (pair.Value != null && pair.Value.Count > 0)
{
foreach (LocalLookupVariable v in pair.Value)
{
DomLocation varStartPos = new DomLocation(lookupVariableLine + v.StartPos.Line, v.StartPos.Column - 1);
DomLocation varEndPos = new DomLocation(lookupVariableLine + v.EndPos.Line, v.EndPos.Column - 1);
if (varStartPos > this.resolvePosition || (!v.EndPos.IsEmpty && varEndPos < this.resolvePosition))
{
continue;
}
col.Add(new LocalVariable(CallingMember, pair.Key, ConvertTypeReference(v.TypeRef), DomRegion.Empty));
}
}
}
}
if (CallingMember is IProperty)
{
IProperty property = (IProperty)callingMember;
if (property.HasSet && editor != null && property.SetRegion.Contains(resolvePosition.Line, editor.CursorColumn))
{
col.Add("value");
}
}
if (CallingMember is IEvent)
{
col.Add("value");
}
}
List <string> namespaceList = new List <string> ();
namespaceList.Add("");
List <string> namespaceDeclList = new List <string> ();
namespaceDeclList.Add("");
if (unit != null)
{
foreach (IUsing u in unit.Usings)
{
foreach (string alias in u.Aliases.Keys)
{
col.Add(alias);
}
if (u.Namespaces == null)
{
continue;
}
bool isNamespaceDecl = u.IsFromNamespace && u.Region.Contains(this.resolvePosition);
if (u.IsFromNamespace && !isNamespaceDecl)
{
continue;
}
foreach (string ns in u.Namespaces)
{
namespaceList.Add(ns);
if (isNamespaceDecl)
{
namespaceDeclList.Add(ns);
}
}
}
foreach (object o in dom.GetNamespaceContents(namespaceList, true, true))
{
if (context.FilterEntry(o))
{
continue;
}
if (o is Namespace)
{
Namespace ns = o as Namespace;
bool skip = true;
foreach (string str in namespaceDeclList)
{
if (dom.NamespaceExists(str.Length > 0 ? str + "." + ns.Name : ns.Name))
{
skip = false;
break;
}
}
if (skip)
{
continue;
}
}
//IMember member = o as IMember;
//if (member != null && completionList.Find (member.Name) != null)
// continue;
if (context == ExpressionContext.Attribute)
{
IType t = o as IType;
if (t != null && !t.IsBaseType(attributeType))
{
continue;
}
}
CompletionData data = col.Add(o);
if (data != null && context == ExpressionContext.Attribute && data.CompletionText != null && data.CompletionText.EndsWith("Attribute"))
{
string newText = data.CompletionText.Substring(0, data.CompletionText.Length - "Attribute".Length);
data.SetText(newText);
}
}
CodeTemplateService.AddCompletionDataForMime("text/x-csharp", col.CompletionList);
}
return(col);
}
