internal static async void UpdateCursorPosition(CompletionTextEditorExtension ext, ICompletionWidget widget) { updateSrc.Cancel(); updateSrc = new CancellationTokenSource(); var token = updateSrc.Token; // 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 = await ext.GetCurrentParameterIndex(md.MethodProvider.StartOffset, token); 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); }
// 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); }
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); }
// 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; } if (ext != null) { wnd.TransientFor = ext.document.Editor.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; 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); } }
// 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; }
internal static void HideWindow(CompletionTextEditorExtension ext, ICompletionWidget widget) { currentMethodGroup = null; if (window != null) { window.ChangeOverload(); } UpdateWindow(ext, widget); }
public static void HideWindow(CompletionTextEditorExtension ext, ICompletionWidget widget) { methods.Clear(); if (window != null) { window.ChangeOverload(); } UpdateWindow(ext, widget); }
internal static async void UpdateCursorPosition(CompletionTextEditorExtension ext, ICompletionWidget widget) { updateSrc.Cancel(); updateSrc = new CancellationTokenSource(); var token = updateSrc.Token; // Called after the key has been processed by the editor if (currentMethodGroup == null) { return; } var actualMethodGroup = new MethodData(); actualMethodGroup.CompletionContext = widget.CurrentCodeCompletionContext; if (!currentMethodGroup.MethodProvider.ApplicableSpan.Contains(ext.Editor.CaretOffset)) { actualMethodGroup.MethodProvider = await ext.ParameterCompletionCommand(widget.CurrentCodeCompletionContext); if (actualMethodGroup.MethodProvider == null) { HideWindow(ext, widget); } } if (actualMethodGroup.MethodProvider != null && (currentMethodGroup == null || !actualMethodGroup.MethodProvider.Equals(currentMethodGroup.MethodProvider))) { currentMethodGroup = actualMethodGroup; } try { int pos = await ext.GetCurrentParameterIndex(currentMethodGroup.MethodProvider.ApplicableSpan.Start, token); if (pos == -1) { if (actualMethodGroup.MethodProvider == null) { currentMethodGroup = null; } else { pos = await ext.GetCurrentParameterIndex(actualMethodGroup.MethodProvider.ApplicableSpan.Start, token); currentMethodGroup = pos >= 0 ? actualMethodGroup : null; } } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. UpdateOverload(ext, widget, token); // Refresh. UpdateWindow(ext, widget); } catch (OperationCanceledException) { } catch (Exception e) { LoggingService.LogError("Error while updating cursor position for parameter info window.", e); } }
internal static void UpdateWindow(CompletionTextEditorExtension textEditorExtension, ICompletionWidget completionWidget) { // Updates the parameter information window from the information // of the current method overload if (methods.Count > 0) { if (window == null) { window = new ParameterInformationWindow(); window.Ext = textEditorExtension; window.Widget = completionWidget; window.SizeAllocated += delegate(object o, SizeAllocatedArgs args) { if (args.Allocation.Width == lastW && args.Allocation.Height == lastH && wasVisi == CompletionWindowManager.IsVisible) { return; } PositionParameterInfoWindow(args.Allocation); }; window.Hidden += delegate { lastW = -1; lastH = -1; }; } else { window.Ext = textEditorExtension; window.Widget = completionWidget; } wasAbove = false; var lastMethod = methods [methods.Count - 1]; int curParam = window.Ext != null?window.Ext.GetCurrentParameterIndex(lastMethod.MethodProvider.StartOffset) : 0; var geometry2 = DesktopService.GetUsableMonitorGeometry(window.Screen, window.Screen.GetMonitorAtPoint(X, Y)); window.ShowParameterInfo(lastMethod.MethodProvider, lastMethod.CurrentOverload, curParam - 1, geometry2.Width); window.ChangeOverload(); PositionParameterInfoWindow(window.Allocation); window.Show(); } if (methods.Count == 0) { if (window != null) { // window.HideParameterInfo (); DestroyWindow(); wasAbove = false; wasVisi = false; lastW = -1; lastH = -1; } return; } }
// 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); }
// 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); }
internal static async void UpdateWindow(CompletionTextEditorExtension textEditorExtension, ICompletionWidget completionWidget) { // Updates the parameter information window from the information // of the current method overload if (currentMethodGroup != null) { if (window == null) { window = new ParameterInformationWindow(); window.Ext = textEditorExtension; window.Widget = completionWidget; window.BoundsChanged += (o, args) => { if (window.Size.Width == lastW && window.Size.Height == lastH && wasCompletionWindowVisible == (CompletionWindowManager.Wnd?.Visible ?? false)) { return; } PositionParameterInfoWindow(window.ScreenBounds); }; window.Hidden += delegate { lastW = -1; lastH = -1; }; } else { window.Ext = textEditorExtension; window.Widget = completionWidget; } wasAbove = false; int curParam = window.Ext != null ? await window.Ext.GetCurrentParameterIndex(currentMethodGroup.MethodProvider.StartOffset) : 0; var geometry2 = window.Visible ? window.Screen.VisibleBounds.Width : 480; window.ShowParameterInfo(currentMethodGroup.MethodProvider, currentMethodGroup.CurrentOverload, curParam - 1, (int)geometry2); PositionParameterInfoWindow(window.ScreenBounds); } if (currentMethodGroup == null) { if (window != null) { window.HideParameterInfo(); // DestroyWindow (); wasAbove = false; wasCompletionWindowVisible = false; lastW = -1; lastH = -1; } return; } }
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; }
internal static async void UpdateWindow(CompletionTextEditorExtension textEditorExtension, ICompletionWidget completionWidget) { // Updates the parameter information window from the information // of the current method overload if (currentMethodGroup != null) { if (window == null) { window = new ParameterInformationWindow(); window.Ext = textEditorExtension; window.Widget = completionWidget; window.SizeAllocated += delegate(object o, SizeAllocatedArgs args) { if (args.Allocation.Width == lastW && args.Allocation.Height == lastH && wasCompletionWindowVisible == (CompletionWindowManager.Wnd?.Visible ?? false)) { return; } PositionParameterInfoWindow(args.Allocation); }; window.Hidden += delegate { lastW = -1; lastH = -1; }; } else { window.Ext = textEditorExtension; window.Widget = completionWidget; } wasAbove = false; int curParam = window.Ext != null ? await window.Ext.GetCurrentParameterIndex(currentMethodGroup.MethodProvider.StartOffset) : 0; var geometry2 = DesktopService.GetUsableMonitorGeometry(window.Screen.Number, window.Screen.GetMonitorAtPoint(X, Y)); window.ShowParameterInfo(currentMethodGroup.MethodProvider, currentMethodGroup.CurrentOverload, curParam - 1, (int)geometry2.Width); PositionParameterInfoWindow(window.Allocation); } if (currentMethodGroup == null) { if (window != null) { window.HideParameterInfo(); // DestroyWindow (); wasAbove = false; wasCompletionWindowVisible = false; lastW = -1; lastH = -1; } return; } }
public void PresentItems(ITrackingSpan triggerSpan, IList <CompletionItem> items, CompletionItem selectedItem, CompletionItem suggestionModeItem, bool suggestionMode, bool isSoftSelected, ImmutableArray <CompletionItemFilter> completionItemFilters, string filterText) { var result = new CompletionDataList(); foreach (var item in items) { if (string.IsNullOrEmpty(item.DisplayText)) { continue; } result.Add(WrapItem(item)); } if (suggestionMode) { result.AutoSelect = false; } if (filterText != null) { result.DefaultCompletionString = filterText; } if (suggestionModeItem != null) { result.DefaultCompletionString = suggestionModeItem.DisplayText; result.AutoSelect = false; } if (selectedItem != null) { result.DefaultCompletionString = selectedItem.DisplayText; } // TODO: isSoftSelected // TODO: completionItemFilters var editor = IdeApp.Workbench.ActiveDocument.Editor; CompletionTextEditorExtension completionEditorExtension = editor.GetContent <CompletionTextEditorExtension> (); completionEditorExtension.ShowCompletion(result); if (!_isAdvised) { CompletionWindowManager.Wnd.SelectionChanged += OnSelectionChanged; CompletionWindowManager.WordCompleted += OnWordCompleted; CompletionWindowManager.WindowClosed += OnWindowClosed; // TODO: Would be nice it we could better detect whether we've already advised on the completion window _isAdvised = true; } }
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; }
// 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; }
internal static async void UpdateCursorPosition(CompletionTextEditorExtension ext, ICompletionWidget widget) { updateSrc.Cancel(); updateSrc = new CancellationTokenSource(); var token = updateSrc.Token; // Called after the key has been processed by the editor if (currentMethodGroup == null) { return; } var actualMethodGroup = new MethodData(); actualMethodGroup.CompletionContext = widget.CurrentCodeCompletionContext; actualMethodGroup.MethodProvider = await ext.ParameterCompletionCommand(widget.CurrentCodeCompletionContext); if (actualMethodGroup.MethodProvider != null && (currentMethodGroup == null || !actualMethodGroup.MethodProvider.Equals(currentMethodGroup.MethodProvider))) { currentMethodGroup = actualMethodGroup; } int pos = await ext.GetCurrentParameterIndex(currentMethodGroup.MethodProvider.StartOffset, token); if (pos == -1) { if (actualMethodGroup.MethodProvider == null) { currentMethodGroup = null; } else { pos = await ext.GetCurrentParameterIndex(actualMethodGroup.MethodProvider.StartOffset, token); currentMethodGroup = pos >= 0 ? actualMethodGroup : null; } } // If the user enters more parameters than the current overload has, // look for another overload with more parameters. UpdateOverload(ext, widget, token); // Refresh. UpdateWindow(ext, widget); }
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); } }
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); }
public static void ShowWindow(CompletionTextEditorExtension ext, ICompletionWidget widget, CodeCompletionContext ctx, IParameterDataProvider 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; methods.Add(md); UpdateOverload(ext, widget); UpdateWindow(ext, 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 UpdateWindow(CompletionTextEditorExtension textEditorExtension, ICompletionWidget completionWidget) { // Updates the parameter information window from the information // of the current method overload if (currentMethodGroup != null) { if (window == null) { window = new ParameterInformationWindow(); window.Ext = textEditorExtension; window.Widget = completionWidget; window.BoundsChanged += WindowBoundsChanged; window.Hidden += delegate { lastW = -1; lastH = -1; }; } else { window.Ext = textEditorExtension; window.Widget = completionWidget; } wasAbove = false; PositionParameterInfoWindow(); } if (currentMethodGroup == null) { if (window != null) { window.HideParameterInfo(); // DestroyWindow (); wasAbove = false; wasCompletionWindowVisible = false; lastW = -1; lastH = -1; } return; } }
// 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); }
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); }
// 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 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); }
internal static void PostProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { }
public static void RepositionWindow(CompletionTextEditorExtension ext, ICompletionWidget widget) { UpdateWindow(ext, widget); }
internal static void HideWindow (CompletionTextEditorExtension ext, ICompletionWidget widget) { currentMethodGroup = null; if (window != null) window.ChangeOverload (); UpdateWindow (ext, widget); }
static void UpdateOverload (CompletionTextEditorExtension ext, ICompletionWidget widget) { 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 = ext.GuessBestMethodOverload (currentMethodGroup.MethodProvider, currentMethodGroup.CurrentOverload); if (bestOverload != -1) { currentMethodGroup.CurrentOverload = bestOverload; window.ChangeOverload (); UpdateWindow (ext, widget); } }
public static void PostProcessKeyEvent(CompletionTextEditorExtension ext, ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier) { }
// 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 async void UpdateWindow (CompletionTextEditorExtension textEditorExtension, ICompletionWidget completionWidget) { // Updates the parameter information window from the information // of the current method overload if (currentMethodGroup != null) { if (window == null) { window = new ParameterInformationWindow (); window.Ext = textEditorExtension; window.Widget = completionWidget; window.SizeAllocated += delegate(object o, SizeAllocatedArgs args) { if (args.Allocation.Width == lastW && args.Allocation.Height == lastH && wasVisi == CompletionWindowManager.IsVisible) return; PositionParameterInfoWindow (args.Allocation); }; window.Hidden += delegate { lastW = -1; lastH = -1; }; } else { window.Ext = textEditorExtension; window.Widget = completionWidget; } wasAbove = false; int curParam = window.Ext != null ? await window.Ext.GetCurrentParameterIndex (currentMethodGroup.MethodProvider.StartOffset) : 0; var geometry2 = DesktopService.GetUsableMonitorGeometry (window.Screen.Number, window.Screen.GetMonitorAtPoint (X, Y)); window.ShowParameterInfo (currentMethodGroup.MethodProvider, currentMethodGroup.CurrentOverload, curParam - 1, (int)geometry2.Width); PositionParameterInfoWindow (window.Allocation); } if (currentMethodGroup == null) { if (window != null) { window.HideParameterInfo (); // DestroyWindow (); wasAbove = false; wasVisi = false; lastW = -1; lastH = -1; } return; } }
internal static void HideWindow (CompletionTextEditorExtension ext, ICompletionWidget widget) { methods.Clear (); if (window != null) window.ChangeOverload (); UpdateWindow (ext, widget); }
internal static void UpdateCursorPosition (CompletionTextEditorExtension ext, ICompletionWidget widget) { // 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); }
public static void HideWindow(CompletionTextEditorExtension ext, ICompletionWidget widget) { methods.Clear(); UpdateWindow(ext, widget); }
internal static void PostProcessKeyEvent(CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { }
public ProjectedFilterCompletionTextEditorExtension(CompletionTextEditorExtension completionTextEditorExtension, IReadOnlyList <Projection> projections) { this.completionTextEditorExtension = completionTextEditorExtension; this.projections = projections; }
internal static async void UpdateCursorPosition (CompletionTextEditorExtension ext, ICompletionWidget widget) { updateSrc.Cancel (); updateSrc = new CancellationTokenSource (); var token = updateSrc.Token; // Called after the key has been processed by the editor if (currentMethodGroup == null) return; var actualMethodGroup = new MethodData (); actualMethodGroup.CompletionContext = widget.CurrentCodeCompletionContext; actualMethodGroup.MethodProvider = await ext.ParameterCompletionCommand (widget.CurrentCodeCompletionContext); if (actualMethodGroup.MethodProvider != null && !actualMethodGroup.MethodProvider.Equals (currentMethodGroup.MethodProvider)) currentMethodGroup = actualMethodGroup; int pos = await ext.GetCurrentParameterIndex (currentMethodGroup.MethodProvider.StartOffset, token); if (pos == -1) { if (actualMethodGroup.MethodProvider == null) { currentMethodGroup = null; } else { pos = await ext.GetCurrentParameterIndex (actualMethodGroup.MethodProvider.StartOffset, token); currentMethodGroup = pos >= 0 ? actualMethodGroup : null; } } // 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); }
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 RepositionWindow (CompletionTextEditorExtension ext, ICompletionWidget widget) { UpdateWindow (ext, widget); }
public ProjectedFilterCompletionTextEditorExtension(CompletionTextEditorExtension completionTextEditorExtension, IReadOnlyList <Projection> projections) { this.completionTextEditorExtension = completionTextEditorExtension; this.projections = projections; completionTextEditorExtension.UnsubscribeCompletionContextChanged(); }
// 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 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); UpdateWindow (ext, widget); }