public static void PostProcessKeyEvent(CompletionTextEditorExtension ext, ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier) { // Called after the key has been processed by the editor if (methods.Count == 0) { return; } for (int n = 0; n < methods.Count; n++) { // If the cursor is outside of any of the methods parameter list, discard the // information window for that method. MethodData md = methods [n]; int pos = ext.GetCurrentParameterIndex(md.MethodProvider.StartOffset); if (pos == -1) { methods.RemoveAt(n); n--; } } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. UpdateOverload(ext, widget); // Refresh. UpdateWindow(ext, widget); }
/// <summary> /// Get the index of the parameter where the cursor is currently positioned. /// </summary> /// <param name="ctx"> /// A <see cref="CodeCompletionContext"/> /// </param> /// <returns> /// A <see cref="System.Int32"/>: The index of the parameter, /// 0 for no parameter entered, /// -1 for outside the list /// </returns> public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx) { int cursor = document.Editor.Caret.Offset; int i = ctx.TriggerOffset; if (i > cursor) { return(-1); } else if (i == cursor) { return(1); } int parameterIndex = 1; while (i++ < cursor) { char ch = document.Editor.GetCharAt(i - 1); if (ch == ',') { parameterIndex++; } else if (ch == ')') { return(-1); } } return(parameterIndex); }
bool ShowListWindow(char firstChar, ICompletionDataProvider provider, ICompletionWidget completionWidget, ICodeCompletionContext completionContext, CompletionDelegate closedDelegate) { if (mutableProvider != null) { mutableProvider.CompletionDataChanging -= OnCompletionDataChanging; mutableProvider.CompletionDataChanged -= OnCompletionDataChanged; } this.provider = provider; this.completionContext = completionContext; this.closedDelegate = closedDelegate; mutableProvider = provider as IMutableCompletionDataProvider; if (mutableProvider != null) { mutableProvider.CompletionDataChanging += OnCompletionDataChanging; mutableProvider.CompletionDataChanged += OnCompletionDataChanged; if (mutableProvider.IsChanging) { OnCompletionDataChanging(null, null); } } this.completionWidget = completionWidget; this.firstChar = firstChar; return(FillList()); }
public void HideParameterInfo() { ChangeOverload(); Hide(); Ext = null; Widget = null; }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. internal static bool ProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { if (methods.Count == 0) return false; MethodData cmd = methods [methods.Count - 1]; if (descriptor.SpecialKey == SpecialKey.Down) { if (cmd.MethodProvider.Count <= 1) return false; if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1) cmd.CurrentOverload ++; else cmd.CurrentOverload = 0; window.ChangeOverload (); UpdateWindow (ext, widget); return true; } else if (descriptor.SpecialKey == SpecialKey.Up) { if (cmd.MethodProvider.Count <= 1) return false; if (cmd.CurrentOverload > 0) cmd.CurrentOverload --; else cmd.CurrentOverload = cmd.MethodProvider.Count - 1; window.ChangeOverload (); UpdateWindow (ext, widget); return true; } else if (descriptor.SpecialKey == SpecialKey.Escape) { HideWindow (ext, widget); return true; } return false; }
public static bool ShowWindow (char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext, System.Action closedDelegate) { try { if (wnd == null) { wnd = new CompletionListWindow (); wnd.WordCompleted += HandleWndWordCompleted; } try { if (!wnd.ShowListWindow (firstChar, list, completionWidget, completionContext, closedDelegate)) { if (list is IDisposable) ((IDisposable)list).Dispose (); DestroyWindow (); return false; } if (ForceSuggestionMode) wnd.AutoSelect = false; OnWindowShown (EventArgs.Empty); return true; } catch (Exception ex) { LoggingService.LogError (ex.ToString ()); return false; } } finally { ParameterInformationWindowManager.UpdateWindow (completionWidget); } }
// ext may be null, but then parameter completion don't work public static bool ShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext) { try { if (ext != null) { int inserted = ext.document.Editor.EnsureCaretIsNotVirtual (); if (inserted > 0) completionContext.TriggerOffset = ext.document.Editor.Caret.Offset; } if (wnd == null) { wnd = new CompletionListWindow (); wnd.WordCompleted += HandleWndWordCompleted; } wnd.Extension = ext; try { if (!wnd.ShowListWindow (firstChar, list, completionWidget, completionContext)) { if (list is IDisposable) ((IDisposable)list).Dispose (); HideWindow (); return false; } if (ForceSuggestionMode) wnd.AutoSelect = false; wnd.Show (); DesktopService.RemoveWindowShadow (wnd); OnWindowShown (EventArgs.Empty); return true; } catch (Exception ex) { LoggingService.LogError (ex.ToString ()); return false; } } finally { ParameterInformationWindowManager.UpdateWindow (ext, completionWidget); } }
static void UpdateOverload(ICompletionWidget widget) { if (methods.Count == 0) { return; } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. MethodData md = methods [methods.Count - 1]; int cparam = md.MethodProvider.GetCurrentParameterIndex(widget, md.CompletionContext); if (cparam > md.MethodProvider.GetParameterCount(md.CurrentOverload)) { // Look for an overload which has more parameters int bestOverload = -1; int bestParamCount = int.MaxValue; for (int n = 0; n < md.MethodProvider.OverloadCount; n++) { int pc = md.MethodProvider.GetParameterCount(n); if (pc < bestParamCount && pc >= cparam) { bestOverload = n; bestParamCount = pc; } } if (bestOverload != -1) { md.CurrentOverload = bestOverload; } } }
public static void ShowWindow (char firstChar, ICompletionDataProvider provider, ICompletionWidget completionWidget, ICodeCompletionContext completionContext, CompletionDelegate closedDelegate) { try { if (!wnd.ShowListWindow (firstChar, provider, completionWidget, completionContext, closedDelegate)) { provider.Dispose (); return; } // makes control-space in midle of words to work string text = wnd.completionWidget.GetCompletionText (completionContext); if (text.Length == 0) { text = provider.DefaultCompletionString; if (text != null && text.Length > 0) wnd.SelectEntry (text); return; } wnd.PartialWord = text; //if there is only one matching result we take it by default if (wnd.IsUniqueMatch && !wnd.IsChanging) { wnd.UpdateWord (); wnd.Hide (); } } catch (Exception ex) { Console.WriteLine (ex); } }
public static void PostProcessKeyEvent (ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier) { // Called after the key has been processed by the editor if (methods.Count == 0) return; for (int n=0; n<methods.Count; n++) { // If the cursor is outside of any of the methods parameter list, discard the // information window for that method. MethodData md = methods [n]; int pos = md.MethodProvider.GetCurrentParameterIndex (widget, md.CompletionContext); if (pos == -1) { methods.RemoveAt (n); n--; } } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. UpdateOverload (widget); // Refresh. UpdateWindow (widget); }
public static bool ShowWindow(char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext, System.Action closedDelegate) { try { if (wnd == null) { wnd = new CompletionListWindow(); wnd.WordCompleted += HandleWndWordCompleted; } try { if (!wnd.ShowListWindow(firstChar, list, completionWidget, completionContext, closedDelegate)) { if (list is IDisposable) { ((IDisposable)list).Dispose(); } DestroyWindow(); return(false); } if (ForceSuggestionMode) { wnd.AutoSelect = false; } OnWindowShown(EventArgs.Empty); return(true); } catch (Exception ex) { LoggingService.LogError(ex.ToString()); return(false); } } finally { ParameterInformationWindowManager.UpdateWindow(completionWidget); } }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. public static bool ProcessKeyEvent (ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier) { if (methods.Count == 0) return false; MethodData cmd = methods [methods.Count - 1]; if (key == Gdk.Key.Down) { if (cmd.MethodProvider.OverloadCount <= 1) return false; if (cmd.CurrentOverload < cmd.MethodProvider.OverloadCount - 1) cmd.CurrentOverload ++; else cmd.CurrentOverload = 0; UpdateWindow (widget); return true; } else if (key == Gdk.Key.Up) { if (cmd.MethodProvider.OverloadCount <= 1) return false; if (cmd.CurrentOverload > 0) cmd.CurrentOverload --; else cmd.CurrentOverload = cmd.MethodProvider.OverloadCount - 1; UpdateWindow (widget); return true; } else if (key == Gdk.Key.Escape) { HideWindow (widget); return true; } return false; }
// Returns the index of the parameter where the cursor is currently positioned. // -1 means the cursor is outside the method parameter list // 0 means no parameter entered // > 0 is the index of the parameter (1-based) public int GetCurrentParameterIndex (ICompletionWidget widget, CodeCompletionContext ctx) { int cursor = widget.CurrentCodeCompletionContext.TriggerOffset; int i = ctx.TriggerOffset; if (i < 0 || i >= editor.Length || editor.GetCharAt (i) == ')') return -1; if (i > cursor) return -1; else if (i == cursor) return 0; int parameterIndex = 1; while (i++ < cursor) { if (i >= widget.TextLength) break; char ch = widget.GetChar (i); if (ch == ',') parameterIndex++; else if (ch == ')') return -1; } return parameterIndex; }
public void InsertCompletionText(ICompletionWidget widget, CodeCompletionContext context) { // insert add/remove event handler code after +=/-= editor.Replace (initialOffset, editor.Caret.Offset - initialOffset, this.DisplayText + ";"); // Search opening bracket of member int pos = editor.Document.LocationToOffset (callingMember.BodyRegion.Start.Line - 1, callingMember.BodyRegion.Start.Column - 1); while (pos < editor.Document.Length && editor.Document.GetCharAt (pos) != '{') { pos++; } // Search closing bracket of member pos = editor.Document.GetMatchingBracketOffset (pos) + 1; pos = Math.Max (0, Math.Min (pos, editor.Document.Length - 1)); // Insert new event handler after closing bracket string indent = editor.Document.GetLine (callingMember.Location.Line).GetIndentation (editor.Document); StringBuilder sb = new StringBuilder (); sb.AppendLine (); sb.AppendLine (); sb.Append (indent); if (callingMember.IsStatic) sb.Append ("static "); sb.Append ("void ");sb.Append (this.DisplayText);sb.Append (' ');sb.Append (this.parameterList);sb.AppendLine (); sb.Append (indent);sb.Append ("{");sb.AppendLine (); sb.Append (indent);sb.Append (TextEditorProperties.IndentString); int cursorPos = pos + sb.Length; sb.AppendLine (); sb.Append (indent);sb.Append ("}"); editor.Insert (pos, sb.ToString ()); editor.Caret.Offset = cursorPos; }
internal void InitializeListWindow(ICompletionWidget completionWidget, CodeCompletionContext completionContext) { if (completionWidget == null) { throw new ArgumentNullException("completionWidget"); } if (completionContext == null) { throw new ArgumentNullException("completionContext"); } if (mutableList != null) { mutableList.Changing -= OnCompletionDataChanging; mutableList.Changed -= OnCompletionDataChanged; HideFooter(); } ResetState(); CompletionWidget = completionWidget; CodeCompletionContext = completionContext; string text = CompletionWidget.GetCompletionText(CodeCompletionContext); initialWordLength = CompletionWidget.SelectedLength > 0 ? 0 : text.Length; StartOffset = CompletionWidget.CaretOffset - initialWordLength; }
public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx) { if (showCompletion) { return 0; } return -1; }
internal static void HideWindow(CompletionTextEditorExtension ext, ICompletionWidget widget) { currentMethodGroup = null; if (window != null) { window.ChangeOverload(); } UpdateWindow(ext, widget); }
protected override void Initialize() { base.Initialize(); defaultCompletionWidget = CompletionWidget; defaultDocumentContext = DocumentContext; defaultEditor = Editor; defaultDocumentContext.Saved += AsyncUpdateDesignerFile; OnParsedDocumentUpdated(); }
// AspProjectDomWrapper domWrapper; public override void Initialize() { base.Initialize(); defaultCompletionWidget = CompletionWidget; defaultDocument = document; defaultDocument.Editor.Caret.PositionChanged += delegate { OnCompletionContextChanged(CompletionWidget, EventArgs.Empty); }; }
public static void HideWindow(CompletionTextEditorExtension ext, ICompletionWidget widget) { methods.Clear(); if (window != null) { window.ChangeOverload(); } UpdateWindow(ext, widget); }
public override void Initialize() { base.Initialize(); CompletionWidget = Document.GetContent <ICompletionWidget> (); if (CompletionWidget != null) { CompletionWidget.CompletionContextChanged += OnCompletionContextChanged; } }
public override void Initialize() { base.Initialize(); defaultCompletionWidget = CompletionWidget; defaultDocument = document; defaultDocument.Editor.Caret.PositionChanged += delegate { OnCompletionContextChanged(CompletionWidget, EventArgs.Empty); }; defaultDocument.Saved += AsyncUpdateDesignerFile; OnParsedDocumentUpdated(); }
protected override void Run(RefactoringOptions options) { Gtk.Menu menu = new Gtk.Menu(); bool resolveDirect; List <string> namespaces = GetResolveableNamespaces(options, out resolveDirect); foreach (string ns in namespaces) { // remove used namespaces for conflict resolving. if (options.Document.CompilationUnit.IsNamespaceUsedAt(ns, options.ResolveResult.ResolvedExpression.Region.Start)) { continue; } Gtk.MenuItem menuItem = new Gtk.MenuItem(string.Format(GettextCatalog.GetString("Add using '{0}'"), ns)); CurrentRefactoryOperationsHandler.ResolveNameOperation resolveNameOperation = new CurrentRefactoryOperationsHandler.ResolveNameOperation(options.Dom, options.Document, options.ResolveResult, ns); menuItem.Activated += delegate { resolveNameOperation.AddImport(); }; menu.Add(menuItem); } if (resolveDirect) { foreach (string ns in namespaces) { Gtk.MenuItem menuItem = new Gtk.MenuItem(string.Format(GettextCatalog.GetString("Add '{0}'"), ns)); CurrentRefactoryOperationsHandler.ResolveNameOperation resolveNameOperation = new CurrentRefactoryOperationsHandler.ResolveNameOperation(options.Dom, options.Document, options.ResolveResult, ns); menuItem.Activated += delegate { resolveNameOperation.ResolveName(); }; menu.Add(menuItem); } } if (menu.Children != null && menu.Children.Length > 0) { menu.ShowAll(); ICompletionWidget widget = options.Document.GetContent <ICompletionWidget> (); CodeCompletionContext codeCompletionContext = widget.CreateCodeCompletionContext(options.GetTextEditorData().Caret.Offset); menu.Popup(null, null, delegate(Gtk.Menu menu2, out int x, out int y, out bool pushIn) { x = codeCompletionContext.TriggerXCoord; y = codeCompletionContext.TriggerYCoord; pushIn = false; }, 0, Gtk.Global.CurrentEventTime); menu.SelectFirst(true); } }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. public static bool ProcessKeyEvent(CompletionTextEditorExtension ext, ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier) { if (methods.Count == 0) { return(false); } MethodData cmd = methods [methods.Count - 1]; if (key == Gdk.Key.Down) { if (cmd.MethodProvider.Count <= 1) { return(false); } if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1) { cmd.CurrentOverload++; } else { cmd.CurrentOverload = 0; } window.ChangeOverload(); UpdateWindow(ext, widget); return(true); } else if (key == Gdk.Key.Up) { if (cmd.MethodProvider.Count <= 1) { return(false); } if (cmd.CurrentOverload > 0) { cmd.CurrentOverload--; } else { cmd.CurrentOverload = cmd.MethodProvider.Count - 1; } window.ChangeOverload(); UpdateWindow(ext, widget); return(true); } else if (key == Gdk.Key.Escape) { HideWindow(ext, widget); return(true); } return(false); }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. internal static bool ProcessKeyEvent(CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { if (methods.Count == 0) { return(false); } MethodData cmd = methods [methods.Count - 1]; if (descriptor.SpecialKey == SpecialKey.Down) { if (cmd.MethodProvider.Count <= 1) { return(false); } if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1) { cmd.CurrentOverload++; } else { cmd.CurrentOverload = 0; } window.ChangeOverload(); UpdateWindow(ext, widget); return(true); } else if (descriptor.SpecialKey == SpecialKey.Up) { if (cmd.MethodProvider.Count <= 1) { return(false); } if (cmd.CurrentOverload > 0) { cmd.CurrentOverload--; } else { cmd.CurrentOverload = cmd.MethodProvider.Count - 1; } window.ChangeOverload(); UpdateWindow(ext, widget); return(true); } else if (descriptor.SpecialKey == SpecialKey.Escape) { HideWindow(ext, widget); return(true); } return(false); }
public ICompletionData[] GenerateCompletionData(ICompletionWidget widget, char charTyped) { CodeTemplateGroup templateGroup = CodeTemplateLoader.GetTemplateGroupPerFilename (fileName); if (templateGroup == null) { return null; } ArrayList completionData = new ArrayList(); foreach (CodeTemplate template in templateGroup.Templates) { completionData.Add(new TemplateCompletionData(template)); } return (ICompletionData[])completionData.ToArray(typeof(ICompletionData)); }
public ProjectedCompletionWidget(ICompletionWidget completionWidget, Projection projection) { if (completionWidget == null) { throw new ArgumentNullException("completionWidget"); } if (projection == null) { throw new ArgumentNullException("projection"); } this.projection = projection; this.completionWidget = completionWidget; }
public override void Initialize() { base.Initialize(); enableCodeCompletion = (bool)PropertyService.Get("EnableCodeCompletion", true); enableParameterInsight = (bool)PropertyService.Get("EnableParameterInsight", true); PropertyService.PropertyChanged += OnPropertyUpdated; CompletionWidget = Document.GetContent <ICompletionWidget> (); if (CompletionWidget != null) { CompletionWidget.CompletionContextChanged += OnCompletionContextChanged; } }
internal static bool OverloadDown (CompletionTextEditorExtension ext, ICompletionWidget widget) { if (currentMethodGroup == null) return false; if (currentMethodGroup.MethodProvider.Count <= 1) return false; if (currentMethodGroup.CurrentOverload < currentMethodGroup.MethodProvider.Count - 1) currentMethodGroup.CurrentOverload ++; else currentMethodGroup.CurrentOverload = 0; window.ChangeOverload (); UpdateWindow (ext, widget); return true; }
public override void Initialize () { base.Initialize (); defaultCompletionWidget = CompletionWidget; defaultDocument = Document; completionBuilder = RazorCompletionBuilderService.GetBuilder ("C#"); defaultDocument.Editor.Document.TextReplacing += UnderlyingDocument_TextReplacing; defaultDocument.Editor.Caret.PositionChanged += delegate { OnCompletionContextChanged (CompletionWidget, EventArgs.Empty); }; }
public override void Initialize() { base.Initialize(); defaultCompletionWidget = CompletionWidget; defaultDocument = Document; completionBuilder = RazorCompletionBuilderService.GetBuilder("C#"); defaultDocument.Editor.Document.TextReplacing += UnderlyingDocument_TextReplacing; defaultDocument.Editor.Caret.PositionChanged += delegate { OnCompletionContextChanged(CompletionWidget, EventArgs.Empty); }; }
public void ShowCompletion (ICompletionDataList completionList) { completionWidget = Document.GetContent <ICompletionWidget> (); currentCompletionContext = completionWidget.CreateCodeCompletionContext (Document.TextEditorData.Caret.Offset); int cpos, wlen; if (!GetCompletionCommandOffset (out cpos, out wlen)) { cpos = Document.TextEditorData.Caret.Offset; wlen = 0; } currentCompletionContext.TriggerOffset = cpos; currentCompletionContext.TriggerWordLength = wlen; CompletionWindowManager.ShowWindow ('\0', completionList, completionWidget, currentCompletionContext, OnCompletionWindowClosed); }
protected override void Initialize() { base.Initialize(); defaultCompletionWidget = CompletionWidget; defaultDocumentContext = DocumentContext; defaultEditor = Editor; completionBuilder = RazorCompletionBuilderService.GetBuilder("C#"); // defaultEditor.TextChanging += UnderlyingDocument_TextReplacing; //syntaxMode = new RazorSyntaxMode (Editor, DocumentContext); //var textEditorData = DocumentContext.GetContent<TextEditorData> (); //if (textEditorData != null) // textEditorData.Document.SyntaxMode = syntaxMode; }
internal static bool OverloadDown (CompletionTextEditorExtension ext, ICompletionWidget widget) { if (methods.Count == 0) return false; MethodData cmd = methods [methods.Count - 1]; if (cmd.MethodProvider.Count <= 1) return false; if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1) cmd.CurrentOverload ++; else cmd.CurrentOverload = 0; window.ChangeOverload (); UpdateWindow (ext, widget); return true; }
public void ShowCompletion(ICompletionDataList completionList) { completionWidget = Document.GetContent <ICompletionWidget> (); currentCompletionContext = completionWidget.CreateCodeCompletionContext(Document.TextEditorData.Caret.Offset); int cpos, wlen; if (!GetCompletionCommandOffset(out cpos, out wlen)) { cpos = Document.TextEditorData.Caret.Offset; wlen = 0; } currentCompletionContext.TriggerOffset = cpos; currentCompletionContext.TriggerWordLength = wlen; CompletionWindowManager.ShowWindow('\0', completionList, completionWidget, currentCompletionContext, OnCompletionWindowClosed); }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. internal static bool ProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { if (currentMethodGroup == null) return false; if (descriptor.SpecialKey == SpecialKey.Down) { return OverloadDown (ext, widget); } else if (descriptor.SpecialKey == SpecialKey.Up) { return OverloadUp (ext, widget); } else if (descriptor.SpecialKey == SpecialKey.Escape) { HideWindow (ext, widget); return true; } return false; }
public override void Initialize() { base.Initialize(); CompletionWindowManager.WindowClosed += HandleWindowClosed; CompletionWidget = Document.GetContent <ICompletionWidget> (); if (CompletionWidget != null) { CompletionWidget.CompletionContextChanged += OnCompletionContextChanged; } document.Editor.Caret.PositionChanged += HandlePositionChanged; document.Editor.Paste += HandlePaste; if (document.Editor.Parent != null) { document.Editor.Parent.TextArea.FocusOutEvent += HandleFocusOutEvent; } }
/* int caretLineNumber; int caretColumn; string[][] commentTags = new string[][] { new string[] {"c", "marks text as code"}, new string[] {"code", "marks text as code"}, new string[] {"example", "A description of the code example\n(must have a <code> tag inside)"}, new string[] {"exception cref=\"\"", "description to an exception thrown"}, new string[] {"list type=\"\"", "A list"}, new string[] {"listheader", "The header from the list"}, new string[] {"item", "A list item"}, new string[] {"term", "A term in a list"}, new string[] {"description", "A description to a term in a list"}, new string[] {"param name=\"\"", "A description for a parameter"}, new string[] {"paramref name=\"\"", "A reference to a parameter"}, new string[] {"permission cref=\"\"", ""}, new string[] {"remarks", "Gives description for a member"}, new string[] {"include file=\"\" path=\"\"", "Includes comments from other files"}, new string[] {"returns", "Gives description for a return value"}, new string[] {"see cref=\"\"", "A reference to a member"}, new string[] {"seealso cref=\"\"", "A reference to a member in the seealso section"}, new string[] {"summary", "A summary of the object"}, new string[] {"value", "A description of a property"} }; */ public ICompletionData[] GenerateCompletionData(ICompletionWidget widget, char charTyped) { /*caretLineNumber = textArea.Caret.Line; caretColumn = textArea.Caret.Column; LineSegment caretLine = textArea.Document.GetLineSegment(caretLineNumber); string lineText = textArea.Document.GetText(caretLine.Offset, caretLine.Length); if (!lineText.Trim().StartsWith("///")) { return null; } */ ArrayList completionData = new ArrayList (); /*foreach (string[] tag in commentTags) { completionData.Add(new CommentCompletionData(tag[0], tag[1])); }*/ return (ICompletionData[])completionData.ToArray (typeof (ICompletionData)); }
public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx) { /* * int cursor = widget.CurrentCodeCompletionContext.TriggerOffset; * var loc=new CodeLocation(ctx.TriggerLineOffset,ctx.TriggerLine); * * if (args.IsTemplateInstanceArguments) * { * * } * else * { * var firstArgLocation = CodeLocation.Empty; * * if (args.ParsedExpression is PostfixExpression_MethodCall) * firstArgLocation = (args.ParsedExpression as PostfixExpression_MethodCall).Arguments[0].Location; * else if (args.ParsedExpression is NewExpression) * firstArgLocation = (args.ParsedExpression as NewExpression).Arguments[0].Location; * else * return -1; * * if (loc < firstArgLocation) * loc = firstArgLocation; * * var code = doc.Editor.Document.GetTextBetween(firstArgLocation.Line,firstArgLocation.Column, scopeMethod.EndLocation.Line, scopeMethod.EndLocation.Column); * * var tr = new StringReader(code); * var parser = new DParser(new Lexer(tr)); * parser.Lexer.SetInitialLocation(firstArgLocation); * parser.Step(); * * var updatedArguments = parser.ArgumentList(); * tr.Close(); * * var lastArg = updatedArguments[updatedArguments.Count - 1]; * * for (int i = 0; i < updatedArguments.Count; i++) * if ((loc >= updatedArguments[i].Location && loc <= updatedArguments[i].EndLocation) || * (i==updatedArguments.Count-1 && loc <= updatedArguments[i].EndLocation)) * return i + 1; * } */ return(1); }
static void UpdateOverload(CompletionTextEditorExtension ext, ICompletionWidget widget) { if (methods.Count == 0) { return; } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. MethodData md = methods [methods.Count - 1]; int cparam = ext.GetCurrentParameterIndex(md.MethodProvider.StartOffset); if (cparam > md.MethodProvider.GetParameterCount(md.CurrentOverload) && !md.MethodProvider.AllowParameterList(md.CurrentOverload)) { // Look for an overload which has more parameters int bestOverload = -1; int bestParamCount = int.MaxValue; for (int n = 0; n < md.MethodProvider.Count; n++) { int pc = md.MethodProvider.GetParameterCount(n); if (pc < bestParamCount && pc >= cparam) { bestOverload = n; bestParamCount = pc; } } if (bestOverload == -1) { for (int n = 0; n < md.MethodProvider.Count; n++) { if (md.MethodProvider.AllowParameterList(n)) { bestOverload = n; break; } } } if (bestOverload != -1) { md.CurrentOverload = bestOverload; } } }
static async void UpdateOverload(CompletionTextEditorExtension ext, ICompletionWidget widget, CancellationToken token) { if (currentMethodGroup == null || window == null) { return; } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. int bestOverload = await ext.GuessBestMethodOverload(currentMethodGroup.MethodProvider, currentMethodGroup.CurrentOverload, token); if (bestOverload != -1) { currentMethodGroup.CurrentOverload = bestOverload; window.ChangeOverload(); UpdateWindow(ext, widget); } }
public static void ShowWindow(ICompletionWidget widget, CodeCompletionContext ctx, IParameterDataProvider provider) { if (provider.OverloadCount == 0) { return; } // There can be several method parameter lists open at the same time, so // they have to be queued. The last one of queue is the one being shown // in the information window. MethodData md = new MethodData(); md.MethodProvider = provider; md.CurrentOverload = 0; md.CompletionContext = ctx; methods.Add(md); UpdateWindow(widget); }
static void UpdateOverload(CompletionTextEditorExtension ext, ICompletionWidget widget) { if (methods.Count == 0 || window == null) { return; } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. MethodData md = methods [methods.Count - 1]; int bestOverload = ext.GuessBestMethodOverload(md.MethodProvider, md.CurrentOverload); if (bestOverload != -1) { md.CurrentOverload = bestOverload; window.ChangeOverload(); UpdateWindow(ext, widget); } }
internal static void ShowWindow(CompletionTextEditorExtension ext, ICompletionWidget widget, CodeCompletionContext ctx, ParameterHintingResult provider) { if (provider.Count == 0) { return; } // There can be several method parameter lists open at the same time, so // they have to be queued. The last one of queue is the one being shown // in the information window. MethodData md = new MethodData(); md.MethodProvider = provider; md.CurrentOverload = 0; md.CompletionContext = ctx; currentMethodGroup = md; UpdateOverload(ext, widget, default(CancellationToken)); UpdateWindow(ext, widget); }
/// <summary> /// Shows the completion window. The ShowListWindow method is internal /// so use reflection to call it. There are no public methods that can /// be used. /// </summary> public static bool ShowListWindow( this CompletionListWindow window, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext) { MethodInfo[] methods = window.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance); foreach (MethodInfo method in methods) { if (method.Name == "ShowListWindow") { if (method.GetParameters().Length == 4) { return((bool)method.Invoke(window, new object[] { firstChar, list, completionWidget, completionContext })); } } } throw new NotImplementedException("CompletListWindow.ShowListWindow not found"); }
// Returns the index of the parameter where the cursor is currently positioned. // -1 means the cursor is outside the method parameter list // 0 means no parameter entered // > 0 is the index of the parameter (1-based) internal int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx) { int cursor = widget.CurrentCodeCompletionContext.TriggerOffset; int i = ctx.TriggerOffset; if (i < 0 || i >= editor.Length || editor.GetCharAt(i) == ')') { return(-1); } if (i > cursor) { return(-1); } else if (i == cursor) { return(0); } int parameterIndex = 1; while (i++ < cursor) { if (i >= widget.TextLength) { break; } char ch = widget.GetChar(i); if (ch == ',') { parameterIndex++; } else if (ch == ')') { return(-1); } } return(parameterIndex); }
public ICompletionData[] GenerateCompletionData(ICompletionWidget widget, char charTyped) { completionData = new ArrayList(); // the parser works with 1 based coordinates caretLineNumber = widget.TriggerLine + 1; caretColumn = widget.TriggerLineOffset + 1; //string expression = TextUtilities.GetExpressionBeforeOffset (textArea, insertIter.Offset); ResolveResult results; IExpressionFinder expressionFinder = parserContext.GetExpressionFinder(fileName); string expression = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(widget, widget.TriggerOffset) : expressionFinder.FindExpression(widget.GetText (0, widget.TriggerOffset), widget.TriggerOffset - 2); if (expression == null) return null; Console.WriteLine ("Expr: |{0}|", expression); //FIXME: This chartyped check is a f*****g *HACK* if (expression == "is" || expression == "as") { string expr = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset (widget, widget.TriggerOffset - 3) : expressionFinder.FindExpression (widget.GetText (0, widget.TriggerOffset), widget.TriggerOffset - 5); AddResolveResults (parserContext.IsAsResolve (expr, caretLineNumber, caretColumn, fileName, widget.GetText (0, widget.TextLength))); return (ICompletionData[])completionData.ToArray (typeof (ICompletionData)); } if (ctrlspace && charTyped != '.') { AddResolveResults (parserContext.CtrlSpace (caretLineNumber, caretColumn, fileName)); return (ICompletionData[])completionData.ToArray (typeof (ICompletionData)); } if (charTyped == ' ') { if (expression == "using" || expression.EndsWith(" using") || expression.EndsWith("\tusing")|| expression.EndsWith("\nusing")|| expression.EndsWith("\rusing")) { string[] namespaces = parserContext.GetNamespaceList ("", true, true); AddResolveResults(new ResolveResult(namespaces)); } } else { //FIXME: I added the null check, #D doesnt need it, why do we? if (fileName != null) { results = parserContext.Resolve (expression, caretLineNumber, caretColumn, fileName, widget.GetText (0, widget.TextLength)); AddResolveResults(results); } } return (ICompletionData[]) completionData.ToArray (typeof (ICompletionData)); }
// ext may be null, but then parameter completion don't work internal static void PrepareShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionWidget completionWidget, CodeCompletionContext completionContext) { isShowing = true; if (wnd == null) { wnd = new CompletionListWindow (); wnd.WordCompleted += HandleWndWordCompleted; } if (ext != null) { var widget = ext.Editor.GetNativeWidget<Gtk.Widget> (); wnd.TransientFor = widget?.Parent?.Toplevel as Gtk.Window; } else { var widget = completionWidget as Gtk.Widget; if (widget != null) { var window = widget.Toplevel as Gtk.Window; if (window != null) wnd.TransientFor = window; } } wnd.Extension = ext; wnd.InitializeListWindow (completionWidget, completionContext); }
internal static int GetCurrentParameterIndex (ICompletionWidget widget, int offset, int memberStart) { int cursor = widget.CurrentCodeCompletionContext.TriggerOffset; int i = offset; if (i > cursor) return -1; if (i == cursor) return 1; int index = memberStart + 1; int depth = 0; do { char c = widget.GetChar (i - 1); if (c == ',' && depth == 1) index++; if (c == '<') depth++; if (c == '>') depth--; i++; } while (i <= cursor && depth > 0); return depth == 0 ? -1 : index; }
public int GetCurrentParameterIndex (ICompletionWidget widget, CodeCompletionContext ctx) { return GetCurrentParameterIndex (widget, ctx.TriggerOffset, 0); }
public override void Initialize() { base.Initialize (); CompletionWindowManager.WindowClosed += HandleWindowClosed; CompletionWidget = Document.GetContent <ICompletionWidget> (); if (CompletionWidget != null) CompletionWidget.CompletionContextChanged += OnCompletionContextChanged; document.Editor.Caret.PositionChanged += HandlePositionChanged; document.Editor.Paste += HandlePaste; if (document.Editor.Parent != null) document.Editor.Parent.TextArea.FocusOutEvent += HandleFocusOutEvent; }
public static void ShowWindow (ICompletionWidget widget, CodeCompletionContext ctx, IParameterDataProvider provider) { if (provider.OverloadCount == 0) return; // There can be several method parameter lists open at the same time, so // they have to be queued. The last one of queue is the one being shown // in the information window. MethodData md = new MethodData (); md.MethodProvider = provider; md.CurrentOverload = 0; md.CompletionContext = ctx; methods.Add (md); UpdateWindow (widget); }
// ext may be null, but then parameter completion don't work internal static bool ShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext) { PrepareShowWindow (ext, firstChar, completionWidget, completionContext); return ShowWindow (list, completionContext); }
internal static void UpdateWindow (ICompletionWidget widget) { // Updates the parameter information window from the information // of the current method overload if (window == null && methods.Count > 0) { window = new ParameterInformationWindow (); wasAbove = false; } if (methods.Count == 0) { if (window != null) { window.Hide (); wasAbove = false; } return; } var ctx = widget.CurrentCodeCompletionContext; MethodData md = methods[methods.Count - 1]; int cparam = md.MethodProvider.GetCurrentParameterIndex (widget, md.CompletionContext); Gtk.Requisition reqSize = window.ShowParameterInfo (md.MethodProvider, md.CurrentOverload, cparam - 1); X = md.CompletionContext.TriggerXCoord; if (CompletionWindowManager.IsVisible) { // place above Y = ctx.TriggerYCoord - ctx.TriggerTextHeight - reqSize.Height - 10; } else { // place below Y = ctx.TriggerYCoord; } Gdk.Rectangle geometry = DesktopService.GetUsableMonitorGeometry (window.Screen, window.Screen.GetMonitorAtPoint (X + reqSize.Width, Y)); if (X + reqSize.Width > geometry.Right) X = geometry.Right - reqSize.Width; if (Y < geometry.Top) Y = ctx.TriggerYCoord; if (wasAbove || Y + reqSize.Height > geometry.Bottom) { Y = Y - ctx.TriggerTextHeight - reqSize.Height - 4; wasAbove = true; } if (CompletionWindowManager.IsVisible) { Rectangle completionWindow = new Rectangle (CompletionWindowManager.X, CompletionWindowManager.Y, CompletionWindowManager.Wnd.Allocation.Width, CompletionWindowManager.Wnd.Allocation.Height); if (completionWindow.IntersectsWith (new Rectangle (X, Y, reqSize.Width, reqSize.Height))) { X = completionWindow.X; Y = completionWindow.Y - reqSize.Height - 6; if (Y < 0) Y = completionWindow.Bottom + 6; } } window.Move (X, Y); window.Show (); }
static void UpdateOverload (ICompletionWidget widget) { if (methods.Count == 0) return; // If the user enters more parameters than the current overload has, // look for another overload with more parameters. MethodData md = methods [methods.Count - 1]; int cparam = md.MethodProvider.GetCurrentParameterIndex (widget, md.CompletionContext); if (cparam > md.MethodProvider.GetParameterCount (md.CurrentOverload)) { // Look for an overload which has more parameters int bestOverload = -1; int bestParamCount = int.MaxValue; for (int n=0; n<md.MethodProvider.OverloadCount; n++) { int pc = md.MethodProvider.GetParameterCount (n); if (pc < bestParamCount && pc >= cparam) { bestOverload = n; bestParamCount = pc; } } if (bestOverload != -1) md.CurrentOverload = bestOverload; } }
public static void HideWindow (ICompletionWidget widget) { methods.Clear (); UpdateWindow (widget); }
public CodeCompletionContextEventArgs (ICompletionWidget widget, CodeCompletionContext codeCompletionContext, string completedWord) { this.Widget = widget; this.CodeCompletionContext = codeCompletionContext; this.CompletedWord = completedWord; }
public override void Initialize () { base.Initialize (); enableCodeCompletion = (bool)PropertyService.Get ("EnableCodeCompletion", true); enableParameterInsight = (bool)PropertyService.Get ("EnableParameterInsight", true); PropertyService.PropertyChanged += OnPropertyUpdated; CompletionWidget = Document.GetContent <ICompletionWidget> (); if (CompletionWidget != null) CompletionWidget.CompletionContextChanged += OnCompletionContextChanged; }
public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx) { /* int cursor = widget.CurrentCodeCompletionContext.TriggerOffset; var loc=new CodeLocation(ctx.TriggerLineOffset,ctx.TriggerLine); if (args.IsTemplateInstanceArguments) { } else { var firstArgLocation = CodeLocation.Empty; if (args.ParsedExpression is PostfixExpression_MethodCall) firstArgLocation = (args.ParsedExpression as PostfixExpression_MethodCall).Arguments[0].Location; else if (args.ParsedExpression is NewExpression) firstArgLocation = (args.ParsedExpression as NewExpression).Arguments[0].Location; else return -1; if (loc < firstArgLocation) loc = firstArgLocation; var code = doc.Editor.Document.GetTextBetween(firstArgLocation.Line,firstArgLocation.Column, scopeMethod.EndLocation.Line, scopeMethod.EndLocation.Column); var tr = new StringReader(code); var parser = new DParser(new Lexer(tr)); parser.Lexer.SetInitialLocation(firstArgLocation); parser.Step(); var updatedArguments = parser.ArgumentList(); tr.Close(); var lastArg = updatedArguments[updatedArguments.Count - 1]; for (int i = 0; i < updatedArguments.Count; i++) if ((loc >= updatedArguments[i].Location && loc <= updatedArguments[i].EndLocation) || (i==updatedArguments.Count-1 && loc <= updatedArguments[i].EndLocation)) return i + 1; } */ return args.CurrentlyTypedArgumentIndex; }
internal static int GetCurrentParameterIndex (ICompletionWidget widget, int offset, int memberStart) { int cursor = widget.CurrentCodeCompletionContext.TriggerOffset; int i = offset; if (i > cursor) return -1; if (i == cursor) return 1; // parameters are 1 based IEnumerable<string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); CSharpIndentEngine engine = new CSharpIndentEngine (MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<CSharpFormattingPolicy> (types)); int index = memberStart + 1; int parentheses = 0; int bracket = 0; do { char c = widget.GetChar (i - 1); engine.Push (c); switch (c) { case '{': if (!engine.IsInsideOrdinaryCommentOrString) bracket++; break; case '}': if (!engine.IsInsideOrdinaryCommentOrString) bracket--; break; case '(': if (!engine.IsInsideOrdinaryCommentOrString) parentheses++; break; case ')': if (!engine.IsInsideOrdinaryCommentOrString) parentheses--; break; case ',': if (!engine.IsInsideOrdinaryCommentOrString && parentheses == 1 && bracket == 0) index++; break; } i++; } while (i <= cursor && parentheses >= 0); return parentheses != 1 || bracket > 0 ? -1 : index; }