public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
if (!session.TextView.Properties.ContainsProperty(SessionKey))
{
return;
}
// Map the trigger point down to our buffer.
var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
return;
}
var currentSnapshot = subjectTriggerPoint.Value.Snapshot;
var querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
var applicableToSpan = currentSnapshot.CreateTrackingSpan(
querySpan.Start.Position,
0,
SpanTrackingMode.EdgeInclusive);
string encouragement = encouragements.GetRandomEncouragement();
var signature = new Signature(applicableToSpan, encouragement, "", "");
signatures.Add(signature);
}
public async System.Threading.Tasks.Task CollectSignatureLists(ISignatureHelpSession newSession)
{
JavaEditor javaEditor = null;
if (TextBuffer.Properties.TryGetProperty<JavaEditor>(typeof(JavaEditor), out javaEditor) &&
javaEditor.TypeRootIdentifier != null)
{
var textReader = new TextSnapshotToTextReader(TextBuffer.CurrentSnapshot) as TextReader;
var position = newSession.GetTriggerPoint(TextBuffer).GetPosition(TextBuffer.CurrentSnapshot);
var paramHelpRequest = ProtocolHandlers.CreateParamHelpRequest(
textReader,
javaEditor.TypeRootIdentifier,
position);
var paramHelpResponse = await javaEditor.JavaPkgServer.Send(javaEditor, paramHelpRequest);
if (paramHelpResponse.responseType == Protocol.Response.ResponseType.ParamHelp &&
paramHelpResponse.paramHelpResponse != null)
{
if (paramHelpResponse.paramHelpResponse.status && paramHelpResponse.paramHelpResponse.signatures.Count != 0)
{
var applicableTo = TextBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(paramHelpResponse.paramHelpResponse.scopeStart, paramHelpResponse.paramHelpResponse.scopeLength), SpanTrackingMode.EdgeInclusive, 0);
int selectedParameterIndex = paramHelpResponse.paramHelpResponse.paramCount;
Signatures = TransformSignatures(TextBuffer, paramHelpResponse.paramHelpResponse.signatures, applicableTo, selectedParameterIndex);
}
}
}
}
public ValueOrderSignature(
string syntax,
string description,
ITrackingSpan trackingSpan,
ISignatureHelpSession session)
{
_propertyName = "Syntax";
_syntax = syntax ?? string.Empty;
_description = description;
_trackingSpan = trackingSpan;
_content = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", _propertyName, _syntax);
_nameParam = new CssPropertyNameParameter(this);
_currentParam = _nameParam;
_session = session;
// In order to dismiss this tip at the appropriate time, I need to listen
// to changes in the text buffer
if (_trackingSpan != null && _session != null)
{
_session.Dismissed += OnSessionDismissed;
_trackingSpan.TextBuffer.Changed += OnTextBufferChanged;
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
SnapshotPoint? point = session.GetTriggerPoint(_buffer.CurrentSnapshot);
if (!point.HasValue)
return;
CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
ParseItem item = document.StyleSheet.ItemBeforePosition(point.Value.Position);
if (item == null)
return;
Declaration dec = item.FindType<Declaration>();
if (dec == null || dec.PropertyName == null || dec.Colon == null)
return;
foreach (ISignature signature in signatures)
{
if (signature is ValueOrderSignature)
{
signatures.RemoveAt(signatures.Count - 1);
break;
}
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
if (!session.TextView.Properties.ContainsProperty(SessionKey))
{
return;
}
// At the moment there is a bug in the javascript provider which causes it to
// repeatedly insert the same Signature values into an ISignatureHelpSession
// instance. There is no way, other than reflection, for us to prevent this
// from happening. Instead we just ensure that our provider runs after
// Javascript and then remove the values they add here
signatures.Clear();
// Map the trigger point down to our buffer.
var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
return;
}
var currentSnapshot = subjectTriggerPoint.Value.Snapshot;
var querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
var applicableToSpan = currentSnapshot.CreateTrackingSpan(
querySpan.Start.Position,
0,
SpanTrackingMode.EdgeInclusive);
string encouragement = encouragements.GetRandomEncouragement();
if (encouragement != null)
{
var signature = new Signature(applicableToSpan, encouragement, "", "");
signatures.Add(signature);
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, System.Collections.Generic.IList<ISignature> signatures)
{
var textBuffer = session.TextView.TextBuffer;
var span = session.CreateTrackingSpan(textBuffer);
var sigs = _provider._Analysis.GetSignatures(textBuffer.CurrentSnapshot, textBuffer, span);
ISignature curSig = null;
foreach (var sig in sigs.Signatures) {
if (sigs.ParameterIndex == 0 || sig.Parameters.Count > sigs.ParameterIndex) {
curSig = sig;
break;
}
}
foreach (var sig in sigs.Signatures) {
signatures.Add(sig);
}
if (curSig != null) {
// save the current sig so we don't need to recalculate it (we can't set it until
// the signatures are added by our caller).
session.Properties.AddProperty(typeof(PythonSignature), curSig);
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
// trigger point
SnapshotPoint? point = session.GetTriggerPoint(snapshot);
if (point == null)
return;
// get syntax tree
SyntaxTree syntaxTree = snapshot.GetSyntaxTree();
var root = syntaxTree.Root as RobotsTxtDocumentSyntax;
// find line in syntax tree
ITextSnapshotLine line = point.Value.GetContainingLine();
RobotsTxtLineSyntax lineSyntax = root.Records.SelectMany(r => r.Lines)
.Where(l => !l.NameToken.IsMissing && !l.DelimiterToken.IsMissing)
.FirstOrDefault(l => l.Span.IntersectsWith(line.Extent));
// found
if (lineSyntax != null)
{
if (lineSyntax.DelimiterToken.Span.Span.End <= point.Value)
{
// get semantic model
ISemanticModel model = syntaxTree.GetSemanticModel();
// add signature
signatures.Add(new RobotsTxtSignature(model, lineSyntax));
}
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
SnapshotPoint? point = session.GetTriggerPoint(_buffer.CurrentSnapshot);
if (!point.HasValue)
return;
CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
ParseItem item = document.StyleSheet.ItemBeforePosition(point.Value.Position);
if (item == null)
return;
Declaration dec = item.FindType<Declaration>();
if (dec == null || dec.PropertyName == null || dec.Colon == null)
return;
var span = _buffer.CurrentSnapshot.CreateTrackingSpan(dec.Colon.Start, dec.Length - dec.PropertyName.Length, SpanTrackingMode.EdgeNegative);
ValueOrderFactory.AddSignatures method = ValueOrderFactory.GetMethod(dec);
if (method != null)
{
signatures.Clear();
method(session, signatures, dec, span);
Dispatcher.CurrentDispatcher.BeginInvoke(
new Action(() => {
session.Properties.AddProperty("dec", dec);
session.Match();
}),
DispatcherPriority.Normal, null);
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, System.Collections.Generic.IList<ISignature> signatures)
{
var span = session.GetApplicableSpan(_textBuffer);
var sigs = _textBuffer.CurrentSnapshot.GetSignatures(span);
ISignature curSig = null;
foreach (var sig in sigs.Signatures) {
if (sigs.ParameterIndex == 0 || sig.Parameters.Count > sigs.ParameterIndex) {
curSig = sig;
break;
}
}
foreach (var sig in sigs.Signatures) {
signatures.Add(sig);
}
if (curSig != null) {
// save the current sig so we don't need to recalculate it (we can't set it until
// the signatures are added by our caller).
session.Properties.AddProperty(typeof(JSignature), curSig);
}
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
if (session.Signatures.Count <= 0) return null;
//TODO: Rob G - Flesh this out to cover various signatures
return session.Signatures[0];
}
/// <summary>
/// Gets the Roslyn sig help session stored in a <see cref="ISignatureHelpSession"/> or null if none
/// </summary>
/// <param name="session">Intellisense sig help session</param>
/// <returns></returns>
public static SignatureHelpSession TryGetSession(ISignatureHelpSession session) {
if (session == null)
return null;
SignatureHelpSession ourSession;
if (session.Properties.TryGetProperty(sigHelpSessionKey, out ourSession))
return ourSession;
return null;
}
void OnSaved(Document document)
{
var point = textView.Caret.Position.BufferPosition;
var triggerPoint = point.Snapshot.CreateTrackingPoint(point.Position, PointTrackingMode.Positive);
if (!provider.SignatureHelpBroker.IsSignatureHelpActive(textView))
{
session = provider.SignatureHelpBroker.TriggerSignatureHelp(textView, triggerPoint, true);
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
JavaSignatureHelpSessionSignatures storedSigs;
if (session.Properties.TryGetProperty<JavaSignatureHelpSessionSignatures>(typeof(JavaSignatureHelpSessionSignatures), out storedSigs))
{
foreach (var sig in storedSigs.Signatures)
signatures.Add(sig);
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
AssertIsForeground();
if (!session.Properties.TryGetProperty<SignatureHelpPresenterSession>(s_augmentSessionKey, out var presenterSession))
{
return;
}
session.Properties.RemoveProperty(s_augmentSessionKey);
presenterSession.AugmentSignatureHelpSession(signatures);
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
ITextSnapshot currentSnapshot = _textBuffer.CurrentSnapshot;
int currentPosition = session.GetTriggerPoint(_textBuffer).GetPosition(currentSnapshot);
ITrackingSpan currentApplicableSpan = currentSnapshot.CreateTrackingSpan(new Span(currentPosition, 0), SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward);
signatures.Add(CreateSignature(_textBuffer, "<content name=\"namedContentArea\" />", "Spools all output in the content element into a named text writer", currentApplicableSpan));
signatures.Add(CreateSignature(_textBuffer, "<content var=\"variable\" />", "Spools all output into a temporary text writer", currentApplicableSpan));
signatures.Add(CreateSignature(_textBuffer, "<content def=\"variable\" />", "Spools all output into a temporary text writer (same as 'var')", currentApplicableSpan));
signatures.Add(CreateSignature(_textBuffer, "<default x=\"xValue\" y=\"yValue\" />", "Declares local variables if a symbol of a given name is not known to be in scope", currentApplicableSpan));
}
void DisplayEncouragement()
{
var point = textView.Caret.Position.BufferPosition;
var triggerPoint = point.Snapshot.CreateTrackingPoint(point.Position, PointTrackingMode.Positive);
if (!provider.SignatureHelpBroker.IsSignatureHelpActive(textView))
{
textView.Properties.AddProperty(EncourageSignatureHelpSource.SessionKey, null);
session = provider.SignatureHelpBroker.TriggerSignatureHelp(textView, triggerPoint, true);
textView.Properties.RemoveProperty(EncourageSignatureHelpSource.SessionKey);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="type">Context type, eg. <see cref="SignatureHelpClassifierContextTypes.ParameterDocumentation"/></param>
/// <param name="session">Signature help session</param>
protected internal SignatureHelpClassifierContext(string type, ISignatureHelpSession session)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
Type = type;
Session = session;
}
public void Dismiss()
{
AssertIsForeground();
if (_editorSessionOpt == null)
{
// No editor session, nothing to do here.
return;
}
_editorSessionOpt.Dismiss();
_editorSessionOpt = null;
}
public ISignatureHelpSession TriggerSignatureHelp(ITextView textView, ITrackingPoint triggerPoint, bool trackCaret)
{
ISignatureHelpSession session = this.CreateSignatureHelpSession(textView, triggerPoint, trackCaret);
session.Start();
if (session.IsDismissed)
{
return(null);
}
return(session);
}
/// <summary>
/// I'm about to be destroyed, so stop listening to events
/// </summary>
private void OnSessionDismissed(object sender, System.EventArgs eventArgs)
{
if (_trackingSpan != null)
{
_trackingSpan.TextBuffer.Changed -= OnTextBufferChanged;
}
if (_session != null)
{
_session.Dismissed -= OnSessionDismissed;
_session = null;
}
}
public virtual void TriggerSignatureHelp([NotNull] ITrackingPoint triggerPoint)
{
Requires.NotNull(triggerPoint, nameof(triggerPoint));
DismissSignatureHelp();
ISignatureHelpSession session = Provider.SignatureHelpBroker.TriggerSignatureHelp(TextView, triggerPoint, true);
if (session != null)
{
session.Dismissed += HandleSignatureHelpDismissed;
SignatureHelpSession = session;
}
}
/// <summary>
/// Gets the Roslyn sig help session stored in a <see cref="ISignatureHelpSession"/> or null if none
/// </summary>
/// <param name="session">Intellisense sig help session</param>
/// <returns></returns>
public static SignatureHelpSession TryGetSession(ISignatureHelpSession session)
{
if (session == null)
{
return(null);
}
SignatureHelpSession ourSession;
if (session.Properties.TryGetProperty(sigHelpSessionKey, out ourSession))
{
return(ourSession);
}
return(null);
}
//</Snippet19>
//<Snippet20>
public ISignature GetBestMatch(ISignatureHelpSession session)
{
if (session.Signatures.Count > 0)
{
ITrackingSpan applicableToSpan = session.Signatures[0].ApplicableToSpan;
string text = applicableToSpan.GetText(applicableToSpan.TextBuffer.CurrentSnapshot);
if (text.Trim().Equals("add")) //get only "add"
{
return(session.Signatures[0]);
}
}
return(null);
}
internal static Task AugmentSignatureHelpSessionAsync(this SignatureHelpSource signatureHelpSource, ISignatureHelpSession session, IList<ISignature> signatures, AstRoot ast) {
var tcs = new TaskCompletionSource<object>();
var ready = signatureHelpSource.AugmentSignatureHelpSession(session, signatures, ast, (o, p) => {
signatureHelpSource.AugmentSignatureHelpSession(session, signatures, ast, null);
tcs.TrySetResult(null);
});
if (ready) {
tcs.TrySetResult(null);
}
return tcs.Task;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="session">Signature help session</param>
/// <param name="parameter">Parameter to classify</param>
/// <param name="nameOffset">Offset of <see cref="IParameter.Name"/> in the text buffer</param>
public ParameterNameSignatureHelpClassifierContext(ISignatureHelpSession session, IParameter parameter, int nameOffset)
: base(SignatureHelpClassifierContextTypes.ParameterName, session)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (nameOffset < 0)
{
throw new ArgumentOutOfRangeException(nameof(nameOffset));
}
Parameter = parameter;
NameOffset = nameOffset;
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
{
if (!REditorSettings.SignatureHelpEnabled || session.IsDismissed)
{
return;
}
var document = REditorDocument.TryFromTextBuffer(_textBuffer);
if (document != null)
{
document.EditorTree.EnsureTreeReady();
AugmentSignatureHelpSession(session, signatures, document.EditorTree.AstRoot, TriggerSignatureHelp);
}
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
if (session.Signatures.Count > 0)
{
var applicableToSpan = session.Signatures.First().ApplicableToSpan;
var text = applicableToSpan.GetText(applicableToSpan.TextBuffer.CurrentSnapshot);
if (text.Trim().Equals("add"))
{
return(session.Signatures.First());
}
}
return(null);
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
{
SnapshotPoint?point = session.GetTriggerPoint(_buffer.CurrentSnapshot);
if (!point.HasValue)
{
return;
}
CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
ParseItem item = document.StyleSheet.ItemBeforePosition(point.Value.Position);
if (item == null)
{
return;
}
Declaration dec = item.FindType <Declaration>();
if (dec == null || dec.PropertyName == null || dec.Colon == null)
{
return;
}
int length = dec.Length - (dec.Colon.Start - dec.Start);
var span = _buffer.CurrentSnapshot.CreateTrackingSpan(dec.Colon.Start, length, SpanTrackingMode.EdgeNegative);
ValueOrderFactory.AddSignatures method = ValueOrderFactory.GetMethod(dec);
if (method != null)
{
signatures.Clear();
method(session, signatures, dec, span);
Dispatcher.CurrentDispatcher.BeginInvoke(
new Action(() =>
{
if (session == null || session.Properties == null)
{
return;
}
session.Properties.AddProperty("dec", dec);
session.Match();
}),
DispatcherPriority.Normal, null);
}
}
public List <ClassificationSpan> GetReplacementSpans(ISignatureHelpSession session)
{
ITextSnapshot snapshot = this.textBuffer.CurrentSnapshot;
int currentVersion = snapshot.Version.VersionNumber;
SnapshotPoint currentPoint = session.GetTriggerPoint(snapshot).Value;
if (replacementSpansVersion != currentVersion || replacementSpansPoint != currentPoint)
{
// TODO: detect when the current point is within the spans and re-use?
this.replacementSpans = this.GetReplacementSpans(currentPoint);
this.replacementSpansVersion = currentVersion;
this.replacementSpansPoint = currentPoint;
}
return(this.replacementSpans);
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures) {
if (!REditorSettings.SignatureHelpEnabled || session.IsDismissed) {
return;
}
var document = REditorDocument.TryFromTextBuffer(_textBuffer);
if (document != null) {
if (!document.EditorTree.IsReady) {
document.EditorTree.InvokeWhenReady((p) => {
var broker = _shell.ExportProvider.GetExportedValue<ISignatureHelpBroker>();
broker.DismissAllSessions((ITextView)p);
broker.TriggerSignatureHelp((ITextView)p);
}, session.TextView, this.GetType(), processNow: true);
}
AugmentSignatureHelpSession(session, signatures, document.EditorTree.AstRoot, TriggerSignatureHelp);
}
}
public SignatureHelp(ISignatureHelpSession session, ITextBuffer subjectBuffer, string functionName,
string documentation, ISignatureInfo signatureInfo) {
FunctionName = functionName;
_signatureInfo = signatureInfo;
Documentation = documentation;
Parameters = null;
Session = session;
Session.Dismissed += OnSessionDismissed;
TextView = session.TextView;
TextView.Caret.PositionChanged += OnCaretPositionChanged;
SubjectBuffer = subjectBuffer;
SubjectBuffer.Changed += OnSubjectBufferChanged;
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
if (session.Signatures.Count > 0)
{
ITrackingSpan applicableToSpan = session.Signatures[0].ApplicableToSpan;
string text = applicableToSpan.GetText(applicableToSpan.TextBuffer.CurrentSnapshot).Trim();
foreach (var sig in session.Signatures)
{
if (text.Equals(sig.Content))
{
return(sig);
}
}
}
return(null);
}
public void Dispose()
{
if (isDisposed)
{
return;
}
isDisposed = true;
CancelFetchItems();
if (session != null)
{
session.Dismissed -= Session_Dismissed;
session.Dismiss();
}
session = null;
signatures.Clear();
Disposed?.Invoke(this, EventArgs.Empty);
}
private void HandleTypeChar(char typedChar)
{
switch (typedChar)
{
case '(':
StartSignatureSession();
break;
case ')':
if (_signatureSession != null)
{
_signatureSession.Dismiss();
_signatureSession = null;
}
break;
}
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
if (session.Signatures.Count > 0)
{
var applicableToSpan = session.Signatures[0].ApplicableToSpan;
var text = applicableToSpan.GetText(applicableToSpan.TextBuffer.CurrentSnapshot);
foreach (var sig in session.Signatures)
{
var sh = sig as RSignatureHelp;
if (sh != null && sh.FunctionName.StartsWithOrdinal(text))
{
return(sig);
}
}
}
return(null);
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
int number = 0;
if (session.Properties.ContainsProperty("dec"))
{
Declaration dec = session.Properties["dec"] as Declaration;
string methodName = ValueOrderFactory.GetMethod(dec).Method.Name;
if (dec.Values.Count > 0 && (methodName == "Margins" || methodName == "Corners"))
{
number = 4 - dec.Values.Count;
}
}
return((session.Signatures != null && session.Signatures.Count > number && number > -1)
? session.Signatures[number]
: null);
}
public SignatureHelp(ISignatureHelpSession session, ITextBuffer subjectBuffer, string functionName,
string documentation, ISignatureInfo signatureInfo)
{
FunctionName = functionName;
_signatureInfo = signatureInfo;
Documentation = documentation;
Parameters = null;
Session = session;
Session.Dismissed += OnSessionDismissed;
TextView = session.TextView;
TextView.Caret.PositionChanged += OnCaretPositionChanged;
SubjectBuffer = subjectBuffer;
SubjectBuffer.Changed += OnSubjectBufferChanged;
}
public SignatureHelpTagger(ISignatureHelpSession session, ITextBuffer buffer, IThemeClassificationTypeService themeClassificationTypeService)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (themeClassificationTypeService == null)
{
throw new ArgumentNullException(nameof(themeClassificationTypeService));
}
this.session = session;
this.buffer = buffer;
this.themeClassificationTypeService = themeClassificationTypeService;
}
public ISignatureHelpSession GetSignatureSession()
{
ISignatureHelpBroker broker = EditorShell.Current.ExportProvider.GetExportedValue <ISignatureHelpBroker>();
var sessions = broker.GetSessions(EditorWindow.CoreEditor.View);
ISignatureHelpSession session = sessions.FirstOrDefault();
int retries = 0;
while (session == null && retries < 10)
{
this.DoIdle(1000);
sessions = broker.GetSessions(EditorWindow.CoreEditor.View);
session = sessions.FirstOrDefault();
retries++;
}
return(session);
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
{
if (!REditorSettings.SignatureHelpEnabled || session.IsDismissed)
{
return;
}
var document = REditorDocument.TryFromTextBuffer(_textBuffer);
if (document != null && !document.EditorTree.IsReady)
{
document.EditorTree.InvokeWhenReady((p) => {
var broker = EditorShell.Current.ExportProvider.GetExportedValue <ISignatureHelpBroker>();
broker.TriggerSignatureHelp((ITextView)p);
}, session.TextView, this.GetType(), processNow: true);
}
AugmentSignatureHelpSession(session, signatures, document.EditorTree.AstRoot, TriggerSignatureHelp);
}
public SignatureHelpCurrentParameterTagger(ISignatureHelpSession session, ITextBuffer buffer, ClassificationTag signatureHelpCurrentParameterClassificationTag)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (signatureHelpCurrentParameterClassificationTag == null)
{
throw new ArgumentNullException(nameof(signatureHelpCurrentParameterClassificationTag));
}
this.session = session;
this.buffer = buffer;
this.signatureHelpCurrentParameterClassificationTag = signatureHelpCurrentParameterClassificationTag;
}
public GLSLSignature(Definition definition, TrackingSpan trackingSpan, Snapshot snapshot, ITextView textView, ISignatureHelpSession session)
{
GLSL.Text.Span span = trackingSpan.GetSpan(snapshot);
this.ApplicableToSpan = snapshot.CreateTrackingSpan(GLSL.Text.Span.Create(span.Start, span.End - 1)).ToITrackingSpan();
this.Content = definition.ToString();
this.Documentation = definition.Documentation;
this.Parameters = new ReadOnlyCollection <IParameter>(definition.GetParameters(this));
this.textView = textView;
this.session = session;
this.textView.TextBuffer.Changed += this.TextBufferChanged;
this.textView.Caret.PositionChanged += this.CaretPositionChanged;
this.session.Dismissed += this.OnDismissed;
this.ComputeCurrentParamter(this.textView.TextBuffer.CurrentSnapshot);
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
int number = 0;
if (session.Properties.ContainsProperty("dec"))
{
Declaration dec = session.Properties["dec"] as Declaration;
string methodName = ValueOrderFactory.GetMethod(dec).Method.Name;
if (dec.Values.Count > 0 && (methodName == "Margins" || methodName == "Corners"))
{
number = 4 - dec.Values.Count;
}
}
return (session.Signatures != null && session.Signatures.Count > number && number > -1)
? session.Signatures[number]
: null;
}
#pragma warning restore 0169
public SignatureHelpPresenter(ISignatureHelpSession session, ITextBufferFactoryService textBufferFactoryService, IContentTypeRegistryService contentTypeRegistryService, IClassifierAggregatorService classifierAggregatorService, IClassificationFormatMap classificationFormatMap)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
if (textBufferFactoryService == null)
{
throw new ArgumentNullException(nameof(textBufferFactoryService));
}
if (contentTypeRegistryService == null)
{
throw new ArgumentNullException(nameof(contentTypeRegistryService));
}
if (classifierAggregatorService == null)
{
throw new ArgumentNullException(nameof(classifierAggregatorService));
}
if (classificationFormatMap == null)
{
throw new ArgumentNullException(nameof(classificationFormatMap));
}
this.session = session;
this.control = new SignatureHelpPresenterControl {
DataContext = this
};
this.signatureTextBuffer = textBufferFactoryService.CreateTextBuffer();
this.otherTextBuffer = textBufferFactoryService.CreateTextBuffer();
signatureTextBuffer.Properties[SignatureHelpConstants.SessionBufferKey] = session;
otherTextBuffer.Properties[SignatureHelpConstants.SessionBufferKey] = session;
this.contentTypeRegistryService = contentTypeRegistryService;
this.classifierAggregatorService = classifierAggregatorService;
this.classificationFormatMap = classificationFormatMap;
this.defaultExtendedContentType = contentTypeRegistryService.GetContentType(DefaultExtendedContentTypeName);
Debug.Assert(defaultExtendedContentType != null);
classificationFormatMap.ClassificationFormatMappingChanged += ClassificationFormatMap_ClassificationFormatMappingChanged;
session.Dismissed += Session_Dismissed;
session.SelectedSignatureChanged += Session_SelectedSignatureChanged;
control.MouseDown += Control_MouseDown;
// This isn't exposed but ReadOnlyObservableCollection<ISignature> does implement the interface
((INotifyCollectionChanged)session.Signatures).CollectionChanged += Signatures_CollectionChanged;
UpdateSelectedSignature();
UpdatePresentationSpan();
}
/// <summary>
/// Triggers Statement completion when appropriate keys are pressed
/// The key combination is CTRL-J or "."
/// The intellisense window is dismissed when one presses ESC key
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnPreprocessKeyDown(object sender, TextCompositionEventArgs e)
{
// We should only receive pre-process events from our text view
Debug.Assert(sender == _textView);
// TODO: We should handle = for signature completion of keyword arguments
// We trigger completions when the user types . or space. Our EditFilter will
// also trigger completions when we receive the VSConstants.VSStd2KCmdID.SHOWMEMBERLIST
// command or the VSConstants.VSStd2KCmdID.COMPLETEWORD command.
//
// We trigger signature help when we receive a "(". We update our current sig when
// we receive a "," and we close sig help when we receive a ")".
switch (e.Text)
{
case ".":
case " ":
//DeleteSelectedSpans();
TriggerCompletionSession(false);
break;
case "(": OpenParenStartSignatureSession(); break;
case ")":
if (_sigHelpSession != null)
{
_sigHelpSession.Dismiss();
_sigHelpSession = null;
}
break;
case ",":
if (_sigHelpSession == null)
{
CommaStartSignatureSession();
}
else
{
CommaAdvanceParameter();
}
break;
}
}
private ISignature CreateSignature(ISignatureHelpSession session,
IFunctionInfo functionInfo, ISignatureInfo signatureInfo,
ITrackingSpan span, AstRoot ast, int position)
{
SignatureHelp sig = new SignatureHelp(session, _textBuffer, functionInfo.Name, string.Empty, signatureInfo);
List <IParameter> paramList = new List <IParameter>();
// Locus points in the pretty printed signature (the one displayed in the tooltip)
var locusPoints = new List <int>();
string signatureString = signatureInfo.GetSignatureString(locusPoints);
sig.Content = signatureString;
sig.ApplicableToSpan = span;
sig.Documentation = functionInfo.Description?.Wrap(Math.Min(SignatureInfo.MaxSignatureLength, sig.Content.Length));
Debug.Assert(locusPoints.Count == signatureInfo.Arguments.Count + 1);
for (int i = 0; i < signatureInfo.Arguments.Count; i++)
{
IArgumentInfo p = signatureInfo.Arguments[i];
if (p != null)
{
int locusStart = locusPoints[i];
int locusLength = locusPoints[i + 1] - locusStart;
Debug.Assert(locusLength >= 0);
Span locus = new Span(locusStart, locusLength);
/// VS may end showing very long tooltip so we need to keep
/// description reasonably short: typically about
/// same length as the function signature.
paramList.Add(
new SignatureParameter(
p.Description.Wrap(
Math.Min(SignatureInfo.MaxSignatureLength, sig.Content.Length)),
locus, locus, p.Name, sig));
}
}
sig.Parameters = new ReadOnlyCollection <IParameter>(paramList);
sig.ComputeCurrentParameter(ast, position);
return(sig);
}
public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures, AstRoot ast, Action <object, string> triggerSession, string packageName)
{
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
int position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);
// Retrieve parameter positions from the current text buffer snapshot
ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position);
if (parametersInfo != null)
{
position = Math.Min(parametersInfo.SignatureEnd, position);
int start = Math.Min(position, snapshot.Length);
int end = Math.Min(parametersInfo.SignatureEnd, snapshot.Length);
ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive);
IFunctionInfo functionInfo = null;
// First try user-defined function
functionInfo = ast.GetUserFunctionInfo(parametersInfo.FunctionName, position);
if (functionInfo == null)
{
var functionIndex = _shell.ExportProvider.GetExportedValue <IFunctionIndex>();
// Then try package functions
packageName = packageName ?? _packageName;
_packageName = null;
// Get collection of function signatures from documentation (parsed RD file)
functionInfo = functionIndex.GetFunctionInfo(parametersInfo.FunctionName, packageName, triggerSession, session);
}
if (functionInfo != null && functionInfo.Signatures != null)
{
foreach (ISignatureInfo signatureInfo in functionInfo.Signatures)
{
ISignature signature = CreateSignature(session, parametersInfo.FunctionName, functionInfo, signatureInfo, applicableToSpan, ast, position);
signatures.Add(signature);
}
session.Properties["functionInfo"] = functionInfo;
return(true);
}
}
return(false);
}
public void AugmentSignatureHelpSession(
ISignatureHelpSession session,
IList<ISignature> signatures
)
{
AssertIsForeground();
if (
!session.Properties.TryGetProperty<SignatureHelpPresenterSession>(
s_augmentSessionKey,
out var presenterSession
)
)
{
return;
}
session.Properties.RemoveProperty(s_augmentSessionKey);
presenterSession.AugmentSignatureHelpSession(signatures);
}
public ISignature GetBestMatch(ISignatureHelpSession session)
{
SignatureHelpManager signatureHelpManager;
if (!session.Properties.TryGetProperty(typeof(SignatureHelpManager), out signatureHelpManager))
return null;
Dictionary<SignatureItem, ISignature> signaturesMap;
if (!session.Properties.TryGetProperty(typeof(Dictionary<SignatureItem, ISignature>), out signaturesMap))
return null;
var model = signatureHelpManager.Model;
if (model == null)
return null;
if (model.Signature == null)
return null;
return signaturesMap[model.Signature];
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, System.Collections.Generic.IList<ISignature> signatures) {
var span = session.GetApplicableSpan(_textBuffer);
var sigs = _textBuffer.CurrentSnapshot.GetSignatures(_provider._serviceProvider, span);
ISignature curSig = sigs.Signatures
.OrderBy(s => s.Parameters.Count)
.FirstOrDefault(s => sigs.ParameterIndex < s.Parameters.Count);
foreach (var sig in sigs.Signatures) {
signatures.Add(sig);
}
if (curSig != null) {
// save the current sig so we don't need to recalculate it (we can't set it until
// the signatures are added by our caller).
session.Properties.AddProperty(typeof(PythonSignature), curSig);
}
}
private bool StartSignatureSession()
{
if (_signatureSession == null)
{
// Move the caret back to the preceding word
SnapshotPoint caret = _textView.Caret.Position.BufferPosition - 1;
TextExtent extent = _textNavigator.GetExtentOfWord(caret);
string word = extent.Span.GetText();
_signatureSession = _signatureBroker.TriggerSignatureHelp(_textView);
_signatureSession.Dismissed += (sender, args) => _signatureSession = null;
_signatureSession.Start();
return(true);
}
return(false);
}
private void TriggerSession()
{
if (_session == null || _session.IsDismissed)
{
if (_quickInfoBroker.IsQuickInfoActive(_view))
{
_quickInfoBroker.GetSessions(_view)[0].Dismiss();
}
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
_session = _signaturehelpBroker.TriggerSignatureHelp(_view);
if (_session != null)
{
_session.Match();
}
}), DispatcherPriority.Normal, null);
}
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
if (signatures.Count == 0)
return;
// Update signature doco
var sig = signatures.First();
if (_sigDocoProp == null) _sigDocoProp = sig.GetType().GetProperty("Documentation");
var newDoco = DocCommentHelper.ProcessParaTags(sig.Documentation);
_sigDocoProp.SetValue(sig, newDoco, null);
// Update parameter doco
if (_paramDocoProp == null && sig.Parameters.Count > 0)
_paramDocoProp = sig.Parameters.First().GetType().GetProperty("Documentation");
foreach (var parameter in sig.Parameters)
{
newDoco = DocCommentHelper.ProcessParaTags(parameter.Documentation);
_paramDocoProp.SetValue(parameter, newDoco, null);
}
}
private static void Corners(ISignatureHelpSession session, IList<ISignature> signatures, Declaration dec, ITrackingSpan span)
{
string value1 = "3px";
string value2 = "4px";
string value3 = "5px";
string value4 = "6px";
if (dec.Values.Count > 0)
{
value1 = dec.Values[0].Text;
value2 = dec.Values.Count > 1 ? dec.Values[1].Text : value2;
value3 = dec.Values.Count > 2 ? dec.Values[2].Text : value3;
value4 = dec.Values.Count > 3 ? dec.Values[3].Text : value4;
}
ValueOrderSignature signature1 = new ValueOrderSignature(
string.Format(CultureInfo.CurrentCulture, "div {{ {0}: {1} {2} {3} {4}; }} ", dec.PropertyName.Text, value1, value2, value3, value4),
string.Format(CultureInfo.CurrentCulture, "[top-left={0}] [top-right={1}] [bottom-right={2}] [bottom-left={3}]", value1, value2, value3, value4),
span, session);
ValueOrderSignature signature2 = new ValueOrderSignature(
string.Format(CultureInfo.CurrentCulture, "div {{ {0}: {1} {2} {3}; }} ", dec.PropertyName.Text, value1, value2, value3),
string.Format(CultureInfo.CurrentCulture, "[top-left={0}] [top-right and bottom-left={1}] [bottom-right={2}]", value1, value2, value3),
span, session);
ValueOrderSignature signature3 = new ValueOrderSignature(
string.Format(CultureInfo.CurrentCulture, "div {{ {0}: {1} {2}; }} ", dec.PropertyName.Text, value1, value2),
string.Format(CultureInfo.CurrentCulture, "[top-left and bottom-right={0}] [top-right and bottom-left={1}]", value1, value2),
span, session);
ValueOrderSignature signature4 = new ValueOrderSignature(
string.Format(CultureInfo.CurrentCulture, "div {{ {0}: {1}; }} ", dec.PropertyName.Text, value1),
string.Format(CultureInfo.CurrentCulture, "[top-left and top-right and bottom-right and bottom-left={0}]", value1),
span, session);
signatures.Add(signature1);
signatures.Add(signature2);
signatures.Add(signature3);
signatures.Add(signature4);
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
SignatureHelpManager signatureHelpManager;
if (!session.Properties.TryGetProperty(typeof(SignatureHelpManager), out signatureHelpManager))
return;
var model = signatureHelpManager.Model;
if (model == null)
return;
var snapshot = _textBuffer.CurrentSnapshot;
var span = model.ApplicableSpan;
var trackingSpan = snapshot.CreateTrackingSpan(span.Start, span.Length, SpanTrackingMode.EdgeExclusive);
var signaturesMap = ToSignatures(trackingSpan, model.Signatures, model.SelectedParameter);
var signatureMapKey = typeof(Dictionary<SignatureItem, ISignature>);
session.Properties.RemoveProperty(signatureMapKey);
session.Properties.AddProperty(signatureMapKey, signaturesMap);
foreach (var signature in model.Signatures)
signatures.Add(signaturesMap[signature]);
}
public int Exec(ref Guid cmdGroup, uint cmdId, uint cmdExecOpt, IntPtr pvaIn, IntPtr pvaOut)
{
char inputCharacter = char.MinValue;
if (cmdGroup == VSConstants.VSStd2K && cmdId == (uint) VSConstants.VSStd2KCmdID.TYPECHAR)
{
inputCharacter = (char) (ushort) Marshal.GetObjectForNativeVariant(pvaIn);
if (inputCharacter.Equals(' '))
{
SnapshotPoint currentPosition = _textView.Caret.Position.BufferPosition - 1;
TextExtent extentOfWord = _navigator.GetExtentOfWord(currentPosition);
string tagName = extentOfWord.Span.GetText();
_session = _broker.TriggerSignatureHelp(_textView);
}
else if (inputCharacter.Equals('>') && _session != null)
{
_session.Dismiss();
_session = null;
}
}
return _nextCommand.Exec(cmdGroup, cmdId, cmdExecOpt, pvaIn, pvaOut);
}
public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures, AstRoot ast, Action<object, string> triggerSession) {
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
int position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);
// Retrieve parameter positions from the current text buffer snapshot
ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position);
if (parametersInfo != null) {
position = Math.Min(parametersInfo.SignatureEnd, position);
int start = Math.Min(position, snapshot.Length);
int end = Math.Min(parametersInfo.SignatureEnd, snapshot.Length);
ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive);
IFunctionInfo functionInfo = null;
// First try user-defined function
functionInfo = ast.GetUserFunctionInfo(parametersInfo.FunctionName, position);
if (functionInfo == null) {
var functionIndex = _shell.ExportProvider.GetExportedValue<IFunctionIndex>();
// Then try package functions
var packageName = _packageName;
_packageName = null;
// Get collection of function signatures from documentation (parsed RD file)
functionInfo = functionIndex.GetFunctionInfo(parametersInfo.FunctionName, packageName, triggerSession, session);
}
if (functionInfo != null && functionInfo.Signatures != null) {
foreach (ISignatureInfo signatureInfo in functionInfo.Signatures) {
ISignature signature = CreateSignature(session, parametersInfo.FunctionName, functionInfo, signatureInfo, applicableToSpan, ast, position);
signatures.Add(signature);
}
session.Properties["functionInfo"] = functionInfo;
return true;
}
}
return false;
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) {
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (int)VSConstants.VSStd2KCmdID.TYPECHAR) {
var ch = (char)(ushort)System.Runtime.InteropServices.Marshal.GetObjectForNativeVariant(pvaIn);
if (_activeSession != null && !_activeSession.IsDismissed) {
if (_activeSession.SelectedCompletionSet.SelectionStatus.IsSelected) {
var completion = _activeSession.SelectedCompletionSet.SelectionStatus.Completion;
string committedBy = String.Empty;
if (_activeSession.SelectedCompletionSet.Moniker == CompletionSource.NodejsRequireCompletionSetMoniker) {
if (completion.InsertionText.StartsWith("'")) { // require(
committedBy = ")";
} else if (completion.InsertionText.EndsWith("'")) { // require('
committedBy = "'";
} else if (completion.InsertionText.EndsWith("\"")) { // require("
committedBy = "\"";
}
} else {
committedBy = NodejsPackage.Instance != null ?
NodejsPackage.Instance.IntellisenseOptionsPage.CompletionCommittedBy :
NodejsConstants.DefaultIntellisenseCompletionCommittedBy;
}
if (committedBy.IndexOf(ch) != -1) {
_activeSession.Commit();
if ((completion.InsertionText.EndsWith("'") && ch == '\'') ||
(completion.InsertionText.EndsWith("\"") && ch == '"')) {
// https://nodejstools.codeplex.com/workitem/960
// ' triggers the completion, but we don't want to insert the quote.
return VSConstants.S_OK;
}
}
} else if (_activeSession.SelectedCompletionSet.Moniker.Equals(CompletionSource.NodejsRequireCompletionSetMoniker) && !IsRequireIdentifierChar(ch)) {
_activeSession.Dismiss();
} else if (!_activeSession.SelectedCompletionSet.Moniker.Equals(CompletionSource.NodejsRequireCompletionSetMoniker) && !IsIdentifierChar(ch)) {
_activeSession.Dismiss();
}
}
int res = _oldTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
if (_activeSession == null || !_activeSession.SelectedCompletionSet.Moniker.Equals(CompletionSource.NodejsRequireCompletionSetMoniker)) {
//Only process the char if we are not in a require completion
HandleChar((char)(ushort)System.Runtime.InteropServices.Marshal.GetObjectForNativeVariant(pvaIn));
}
if (_activeSession != null && !_activeSession.IsDismissed) {
_activeSession.Filter();
}
return res;
}
if (_activeSession != null) {
if (pguidCmdGroup == VSConstants.VSStd2K) {
switch ((VSConstants.VSStd2KCmdID)nCmdID) {
case VSConstants.VSStd2KCmdID.RETURN:
if (/*NodejsPackage.Instance.AdvancedEditorOptionsPage.EnterCommitsIntellisense*/ true &&
!_activeSession.IsDismissed &&
_activeSession.SelectedCompletionSet.SelectionStatus.IsSelected) {
// If the user has typed all of the characters as the completion and presses
// enter we should dismiss & let the text editor receive the enter. For example
// when typing "import sys[ENTER]" completion starts after the space. After typing
// sys the user wants a new line and doesn't want to type enter twice.
bool enterOnComplete = /*NodejsPackage.Instance.AdvancedEditorOptionsPage.AddNewLineAtEndOfFullyTypedWord*/true &&
EnterOnCompleteText();
_activeSession.Commit();
if (!enterOnComplete) {
return VSConstants.S_OK;
}
} else {
_activeSession.Dismiss();
}
break;
case VSConstants.VSStd2KCmdID.TAB:
if (!_activeSession.IsDismissed) {
_activeSession.Commit();
return VSConstants.S_OK;
}
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
case VSConstants.VSStd2KCmdID.DELETE:
case VSConstants.VSStd2KCmdID.DELETEWORDLEFT:
case VSConstants.VSStd2KCmdID.DELETEWORDRIGHT:
int res = _oldTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
if (_activeSession != null && !_activeSession.IsDismissed) {
_activeSession.Filter();
}
return res;
}
}
} else if (_sigHelpSession != null) {
if (pguidCmdGroup == VSConstants.VSStd2K) {
switch ((VSConstants.VSStd2KCmdID)nCmdID) {
case VSConstants.VSStd2KCmdID.BACKSPACE:
bool fDeleted = Backspace();
if (fDeleted) {
return VSConstants.S_OK;
}
break;
case VSConstants.VSStd2KCmdID.LEFT:
_editOps.MoveToPreviousCharacter(false);
UpdateCurrentParameter();
return VSConstants.S_OK;
case VSConstants.VSStd2KCmdID.RIGHT:
_editOps.MoveToNextCharacter(false);
UpdateCurrentParameter();
return VSConstants.S_OK;
case VSConstants.VSStd2KCmdID.HOME:
case VSConstants.VSStd2KCmdID.BOL:
case VSConstants.VSStd2KCmdID.BOL_EXT:
case VSConstants.VSStd2KCmdID.EOL:
case VSConstants.VSStd2KCmdID.EOL_EXT:
case VSConstants.VSStd2KCmdID.END:
case VSConstants.VSStd2KCmdID.WORDPREV:
case VSConstants.VSStd2KCmdID.WORDPREV_EXT:
case VSConstants.VSStd2KCmdID.DELETEWORDLEFT:
_sigHelpSession.Dismiss();
_sigHelpSession = null;
break;
}
}
}
if (pguidCmdGroup == VSConstants.VSStd2K) {
switch ((VSConstants.VSStd2KCmdID)nCmdID) {
case VSConstants.VSStd2KCmdID.SHOWMEMBERLIST:
case VSConstants.VSStd2KCmdID.COMPLETEWORD:
ForceCompletions = true;
try {
TriggerCompletionSession((VSConstants.VSStd2KCmdID)nCmdID == VSConstants.VSStd2KCmdID.COMPLETEWORD);
} finally {
ForceCompletions = false;
}
return VSConstants.S_OK;
case VSConstants.VSStd2KCmdID.QUICKINFO:
TriggerQuickInfo();
return VSConstants.S_OK;
case VSConstants.VSStd2KCmdID.PARAMINFO:
TriggerSignatureHelp();
return VSConstants.S_OK;
}
}
return _oldTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
}
private void OnSignatureSessionDismissed(object sender, System.EventArgs e) {
// We've just been told that our active session was dismissed. We should remove all references to it.
_sigHelpSession.Dismissed -= OnSignatureSessionDismissed;
_sigHelpSession = null;
}
internal void TriggerSignatureHelp() {
if (_sigHelpSession != null) {
_sigHelpSession.Dismiss();
}
_sigHelpSession = SignatureBroker.TriggerSignatureHelp(_textView);
if (_sigHelpSession != null) {
_sigHelpSession.Dismissed += OnSignatureSessionDismissed;
ISignature sig;
if (_sigHelpSession.Properties.TryGetProperty(typeof(NodejsSignature), out sig)) {
_sigHelpSession.SelectedSignature = sig;
IParameter param;
if (_sigHelpSession.Properties.TryGetProperty(typeof(NodejsParameter), out param)) {
((NodejsSignature)sig).SetCurrentParameter(param);
}
}
}
}