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