protected virtual bool DoesCompletionMatchApplicabilityTextDirect(Completion completion, string filterText, CompletionMatchType matchType, bool caseSensitive) { string displayText = string.Empty; if (matchType == CompletionMatchType.MatchDisplayText) { displayText = completion.DisplayText; } else if (matchType == CompletionMatchType.MatchInsertionText) { displayText = completion.InsertionText; } if (PrefixMatch) { return displayText.StartsWith(filterText, !caseSensitive, CultureInfo.CurrentCulture); } StringComparison comparison = caseSensitive ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; if (string.IsNullOrWhiteSpace(filterText)) return false; var words = filterText.Split(new[] {' ', '\t'}, StringSplitOptions.RemoveEmptyEntries); if (words.Length < 1) return false; // empty return words.All(word => WordPrefixContains(displayText, word, comparison)); // all words should match }
public void AugmentCompletionSession(ICompletionSession session, IList<CompletionSet> completionSets) { if (!session.Properties.ContainsProperty(BufferProperties.SessionOriginIntellisense) || !session.TextView.TextBuffer.Properties.ContainsProperty(typeof(IList<CompletionResult>))) { return; } var textBuffer = session.TextView.TextBuffer; var trackingSpan = (ITrackingSpan)textBuffer.Properties.GetProperty(BufferProperties.LastWordReplacementSpan); var list = (IList<CompletionResult>)textBuffer.Properties.GetProperty(typeof(IList<CompletionResult>)); var currentSnapshot = textBuffer.CurrentSnapshot; var filterSpan = currentSnapshot.CreateTrackingSpan(trackingSpan.GetEndPoint(currentSnapshot).Position, 0, SpanTrackingMode.EdgeInclusive); var lineStartToApplicableTo = (ITrackingSpan)textBuffer.Properties.GetProperty(BufferProperties.LineUpToReplacementSpan); Log.DebugFormat("TrackingSpan: {0}", trackingSpan.GetText(currentSnapshot)); Log.DebugFormat("FilterSpan: {0}", filterSpan.GetText(currentSnapshot)); var compList = new List<Completion>(); foreach (var match in list) { var glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupUnknown, StandardGlyphItem.GlyphItemPublic); switch (match.ResultType) { case CompletionResultType.ParameterName: glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupProperty, StandardGlyphItem.GlyphItemPublic); break; case CompletionResultType.Command: glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupMethod, StandardGlyphItem.GlyphItemPublic); break; case CompletionResultType.Type: glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupClass, StandardGlyphItem.GlyphItemPublic); break; case CompletionResultType.Property: glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupProperty, StandardGlyphItem.GlyphItemPublic); break; case CompletionResultType.Method: glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupMethod, StandardGlyphItem.GlyphItemPublic); break; case CompletionResultType.Variable: glyph = _glyphs.GetGlyph(StandardGlyphGroup.GlyphGroupField, StandardGlyphItem.GlyphItemPublic); break; case CompletionResultType.ProviderContainer: case CompletionResultType.ProviderItem: glyph = _glyphs.GetGlyph(match.ResultType == CompletionResultType.ProviderContainer ? StandardGlyphGroup.GlyphOpenFolder : StandardGlyphGroup.GlyphLibrary, StandardGlyphItem.GlyphItemPublic); break; } var completion = new Completion(); completion.Description = match.ToolTip; completion.DisplayText = match.ListItemText; completion.InsertionText = match.CompletionText; completion.IconSource = glyph; completion.IconAutomationText = completion.Description; compList.Add(completion); } completionSets.Add(new PowerShellCompletionSet(string.Empty, string.Empty, trackingSpan, compList, null, filterSpan, lineStartToApplicableTo)); }
public FrameworkElement Create(CompletionSet completionSet, Completion completion, CompletionClassifierKind kind, bool colorize) { if (completionSet == null) throw new ArgumentNullException(nameof(completionSet)); if (completion == null) throw new ArgumentNullException(nameof(completion)); Debug.Assert(completionSet.Completions.Contains(completion)); CompletionClassifierContext context; string defaultContentType; switch (kind) { case CompletionClassifierKind.DisplayText: var inputText = completionSet.ApplicableTo.GetText(completionSet.ApplicableTo.TextBuffer.CurrentSnapshot); context = new CompletionDisplayTextClassifierContext(completionSet, completion, completion.DisplayText, inputText, colorize); defaultContentType = ContentTypes.CompletionDisplayText; break; case CompletionClassifierKind.Suffix: var suffix = (completion as Completion4)?.Suffix ?? string.Empty; context = new CompletionSuffixClassifierContext(completionSet, completion, suffix, colorize); defaultContentType = ContentTypes.CompletionSuffix; break; default: throw new ArgumentOutOfRangeException(nameof(kind)); } var contentType = (completionSet as ICompletionSetContentTypeProvider)?.GetContentType(contentTypeRegistryService, kind); if (contentType == null) contentType = contentTypeRegistryService.GetContentType(defaultContentType); var classifier = GetTextClassifier(contentType); return TextBlockFactory.Create(context.Text, classificationFormatMap.DefaultTextProperties, classifier.GetTags(context).Select(a => new TextRunPropertiesAndSpan(a.Span, classificationFormatMap.GetTextProperties(a.ClassificationType))), TextBlockFactory.Flags.DisableSetTextBlockFontFamily | TextBlockFactory.Flags.DisableFontSize); }
public static void GetMethods(string text, ref List<Completion> completions) { text = remove_comments(text); text = remove_linebreaks(text); string function; int index = 0; int debug_Length = text.Length; bool already_found = false; while (index < text.Length) { already_found = false; if ((function = pull_top_level_function(text, ref index)) != null) { //change 3/28/ lol object comparason without a compartor WHOOPS foreach (Completion e in completions) { if (e.DisplayText == function) { already_found = true; break; } } if (!already_found) { Completion c = new Completion(function); c.Description = "User defined Function"; //c.IconSource = Microsoft.VisualStudio.Language.Intellisense.IGlyphService.GetGlyph(StandardGlyphGroup.GlyphGroupMethod, StandardGlyphItem.GlyphItemPublic) completions.Add(c); already_found = false; } } } }
internal void Select(Completion completion) { this.listViewCompletions.SelectedItem = completion; if (completion != null) { this.listViewCompletions.ScrollIntoView(completion); } }
/// <summary> /// Constructor /// </summary> /// <param name="completionSet">Completion set</param> /// <param name="completion">Completion to classify</param> /// <param name="text">Text to classify</param> /// <param name="colorize">true if it should be colorized</param> protected CompletionClassifierContext(CompletionSet completionSet, Completion completion, string text, bool colorize) : base(text, string.Empty, colorize) { if (completionSet == null) throw new ArgumentNullException(nameof(completionSet)); if (completion == null) throw new ArgumentNullException(nameof(completion)); CompletionSet = completionSet; Completion = completion; }
public CompletionVM(Completion completion, IImageMonikerService imageMonikerService) { if (completion == null) throw new ArgumentNullException(nameof(completion)); if (imageMonikerService == null) throw new ArgumentNullException(nameof(imageMonikerService)); Completion = completion; Completion.Properties.AddProperty(typeof(CompletionVM), this); ImageUIObject = CreateImageUIObject(completion, imageMonikerService); this.imageMonikerService = imageMonikerService; }
public bool IsMatch(Completion completion) { var completionText = completion.TryGetFilterText(); if (completionText == null) return false; if (completionText.IndexOf(searchText, stringComparison) >= 0) return true; if (acronymMatchIndexes != null && TryUpdateAcronymIndexes(completionText)) return true; return false; }
protected override bool DoesCompletionMatchApplicabilityText(Completion completion, string filterText, CompletionMatchType matchType, bool caseSensitive) { if (base.DoesCompletionMatchApplicabilityText(completion, filterText, matchType, caseSensitive)) return true; object parentObject; completion.Properties.TryGetProperty("parentObject", out parentObject); IStepSuggestionGroup<Completion> parentObjectAsGroup = parentObject as IStepSuggestionGroup<Completion>; return parentObjectAsGroup != null && parentObjectAsGroup.Suggestions .Any(stepSuggestion => stepSuggestion.NativeSuggestionItem != null && DoesCompletionMatchApplicabilityText(stepSuggestion.NativeSuggestionItem, filterText, matchType, caseSensitive)); }
protected override bool DoesCompletionMatchApplicabilityText(Completion completion) { if (base.DoesCompletionMatchApplicabilityText(completion)) return true; object parentObject = null; completion.Properties.TryGetProperty<object>("parentObject", out parentObject); IStepSuggestionGroup<Completion> parentObjectAsGroup = parentObject as IStepSuggestionGroup<Completion>; return parentObjectAsGroup != null && parentObjectAsGroup.Suggestions .Any(stepSuggestion => stepSuggestion.NativeSuggestionItem != null && DoesCompletionMatchApplicabilityText(stepSuggestion.NativeSuggestionItem)); }
protected virtual bool DoesCompletionMatchApplicabilityText(Completion completion) { string displayText = string.Empty; if (this._filterMatchType == CompletionMatchType.MatchDisplayText) { displayText = completion.DisplayText; } else if (this._filterMatchType == CompletionMatchType.MatchInsertionText) { displayText = completion.InsertionText; } return displayText.StartsWith(this._filterBufferText, !this._filterCaseSensitive, CultureInfo.CurrentCulture); }
static object CreateImageUIObject(Completion completion, IImageMonikerService imageMonikerService) { var c3 = completion as Completion3; if (c3 == null) { var iconSource = completion.IconSource; if (iconSource == null) return null; return new Image { Width = 16, Height = 16, Source = iconSource, }; } var imageReference = imageMonikerService.ToImageReference(c3.IconMoniker); if (imageReference.IsDefault) return null; return new DsImage { ImageReference = imageReference }; }
public static void Main(string[] args) { string host = "esqa.moneris.com"; string store_id = "store5"; string api_token = "yesguy"; string order_id = "Need_Unique_Order_ID_7cccxxc7_isssssos"; string amount = "1.00"; string txn_number = "12429-222-0"; string crypt = "7"; Completion completion = new Completion(order_id, amount, txn_number, crypt); //completion.SetDynamicDescriptor("123456"); HttpsPostRequest mpgReq = new HttpsPostRequest(host, store_id, api_token, completion); try { Receipt receipt = mpgReq.GetReceipt(); Console.WriteLine("CardType = " + receipt.GetCardType()); Console.WriteLine("TransAmount = " + receipt.GetTransAmount()); Console.WriteLine("TxnNumber = " + receipt.GetTxnNumber()); Console.WriteLine("ReceiptId = " + receipt.GetReceiptId()); Console.WriteLine("TransType = " + receipt.GetTransType()); Console.WriteLine("ReferenceNum = " + receipt.GetReferenceNum()); Console.WriteLine("ResponseCode = " + receipt.GetResponseCode()); Console.WriteLine("ISO = " + receipt.GetISO()); Console.WriteLine("BankTotals = " + receipt.GetBankTotals()); Console.WriteLine("Message = " + receipt.GetMessage()); Console.WriteLine("AuthCode = " + receipt.GetAuthCode()); Console.WriteLine("Complete = " + receipt.GetComplete()); Console.WriteLine("TransDate = " + receipt.GetTransDate()); Console.WriteLine("TransTime = " + receipt.GetTransTime()); Console.WriteLine("Ticket = " + receipt.GetTicket()); Console.WriteLine("TimedOut = " + receipt.GetTimedOut()); Console.WriteLine("IsVisaDebit = " + receipt.GetIsVisaDebit()); } catch (Exception e) { Console.WriteLine(e); } }
private static Completion CreateCompletion(ITextSnapshot snapshot, IGrouping<string, Protocol.Response.AutocompleteResponse.Completion> i) { var ret = new Completion(i.Key, i.First().completionText, GetDescription(i), GetImageSource(i.First()), null); ret.Properties.AddProperty(typeof(ITrackingSpan), GetReplacementSpanFromCompletions(snapshot, i.First())); return ret; }
// // Triggers the completion engine, if insertBestMatch is true, then this will // insert the best match found, this behaves like the shell "tab" which will // complete as much as possible given the options. // void Complete() { Completion completion = AutoCompleteEvent(text.ToString(), cursor); string [] completions = completion.Result; if (completions == null) { HideCompletions(); return; } int ncompletions = completions.Length; if (ncompletions == 0) { HideCompletions(); return; } if (completions.Length == 1) { InsertTextAtCursor(completions [0]); HideCompletions(); } else { int last = -1; for (int p = 0; p < completions [0].Length; p++) { char c = completions [0][p]; for (int i = 1; i < ncompletions; i++) { if (completions [i].Length < p) { goto mismatch; } if (completions [i][p] != c) { goto mismatch; } } last = p; } mismatch: var prefix = completion.Prefix; if (last != -1) { InsertTextAtCursor(completions [0].Substring(0, last + 1)); // Adjust the completions to skip the common prefix prefix += completions [0].Substring(0, last + 1); for (int i = 0; i < completions.Length; i++) { completions [i] = completions [i].Substring(last + 1); } } ShowCompletions(prefix, completions); Render(); ForceCursor(cursor); } }
public ServerStreamingMethodCall(Func <ValueTask <IOutcomingInvocation <TRequest, TResponse> > > invocationFactory) { _invocationFactory = invocationFactory; Completion.LogCompletion(Log); _responseStream.PropagateCompletionFrom(Completion); }
public override async ValueTask <Completion> WriteToAsync(TextWriter writer, TextEncoder encoder, TemplateContext context) { IEnumerable <FluidValue> elements = Array.Empty <FluidValue>(); if (Member != null) { var member = await Member.EvaluateAsync(context); elements = member.Enumerate(); } else if (Range != null) { int start = Convert.ToInt32((await Range.From.EvaluateAsync(context)).ToNumberValue()); int end = Convert.ToInt32((await Range.To.EvaluateAsync(context)).ToNumberValue()); // Cache range if (_rangeElements == null || _rangeStart != start || _rangeEnd != end) { _rangeElements = new List <FluidValue>(); for (var i = start; i <= end; i++) { _rangeElements.Add(NumberValue.Create(i)); } elements = _rangeElements; _rangeStart = start; _rangeEnd = end; } else { elements = _rangeElements; } } if (!elements.Any()) { return(Completion.Normal); } // Apply options if (Offset != null) { var offset = (int)(await Offset.EvaluateAsync(context)).ToNumberValue(); elements = elements.Skip(offset); } if (Limit != null) { var limit = (int)(await Limit.EvaluateAsync(context)).ToNumberValue(); elements = elements.Take(limit); } if (Reversed) { elements = elements.Reverse(); } var list = elements.ToList(); if (!list.Any()) { return(Completion.Normal); } try { var forloop = new ForLoopValue(); var length = forloop.Length = list.Count; context.SetValue("forloop", forloop); for (var i = 0; i < length; i++) { context.IncrementSteps(); var item = list[i]; context.SetValue(Identifier, item); // Set helper variables forloop.Index = i + 1; forloop.Index0 = i; forloop.RIndex = length - i - 1; forloop.RIndex0 = length - i; forloop.First = i == 0; forloop.Last = i == length - 1; Completion completion = Completion.Normal; for (var index = 0; index < Statements.Count; index++) { var statement = Statements[index]; completion = await statement.WriteToAsync(writer, encoder, context); // Restore the forloop property after every statement in case it replaced it, // for instance if it contains a nested for loop context.SetValue("forloop", forloop); if (completion != Completion.Normal) { // Stop processing the block statements break; } } if (completion == Completion.Continue) { // Go to next iteration continue; } if (completion == Completion.Break) { // Leave the loop break; } } } finally { context.LocalScope.Delete("forloop"); } return(Completion.Normal); }
private bool DoesCompletionMatchApplicabilityText(Completion completion) { if (IsUpper(filterBufferText)) { return GetUpperString(completion.DisplayText).StartsWith(this.filterBufferText); } return completion.DisplayText.ToLowerInvariant().Contains(this.filterBufferText.ToLowerInvariant()); }
protected ProcessBase() { Completion.ContinueWithSynchronously((Action <Task>)DisposeRegistrations).IgnoreAwait(); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #region Constructors internal CompletionTooltipCustomization(Completion completion) { this.Text = string.Format(CultureInfo.CurrentCulture, "{0}: {1}", completion.DisplayText, completion.Description); this.FontSize = 24; this.FontStyle = FontStyles.Italic; }
private void AskSequential(IPerfReceiver receiver, Completion<TimeSpan> completion, Stopwatch sw, int messageCount) { if(messageCount == 0) { sw.Stop(); completion.Complete(sw.Elapsed); } receiver.Ask("foo").ContinueWith(t => AskSequential(receiver, completion, sw, messageCount - 1)); }
public void Select(Completion completion) { var newMatchPriority = GetMatchPriority(completion); if (newMatchPriority < matchPriority) { bestCompletion = completion; matchPriority = newMatchPriority; } }
private void ShowCompletion(string enteredText, bool controlSpace) { if (!controlSpace) { Debug.WriteLine("Code Completion: TextEntered: " + enteredText); } else { Debug.WriteLine("Code Completion: Ctrl+Space"); } //only process csharp files and if there is a code completion engine available if (String.IsNullOrEmpty(Document.FileName)) { Debug.WriteLine("No document file name, cannot run code completion"); return; } if (Completion == null) { Debug.WriteLine("Code completion is null, cannot run code completion"); return; } var fileExtension = Path.GetExtension(Document.FileName); fileExtension = fileExtension != null?fileExtension.ToLower() : null; //check file extension to be a c# file (.cs, .csx, etc.) if (fileExtension == null || (!fileExtension.StartsWith(".cs"))) { Debug.WriteLine("Wrong file extension, cannot run code completion"); return; } if (completionWindow == null) { CodeCompletionResult results = null; try { var offset = 0; var doc = GetCompletionDocument(out offset); results = Completion.GetCompletions(doc, offset, controlSpace); } catch (Exception exception) { Debug.WriteLine("Error in getting completion: " + exception); } if (results == null) { return; } if (insightWindow == null && results.OverloadProvider != null) { insightWindow = new OverloadInsightWindow(TextArea); insightWindow.Provider = results.OverloadProvider; insightWindow.Show(); insightWindow.Closed += (o, args) => insightWindow = null; return; } if (completionWindow == null && results != null && results.CompletionData.Any()) { // Open code completion after the user has pressed dot: completionWindow = new CompletionWindow(TextArea); completionWindow.CloseWhenCaretAtBeginning = controlSpace; completionWindow.StartOffset -= results.TriggerWordLength; //completionWindow.EndOffset -= results.TriggerWordLength; IList <ICompletionData> data = completionWindow.CompletionList.CompletionData; foreach (var completion in results.CompletionData.OrderBy(item => item.Text)) { data.Add(completion); } if (results.TriggerWordLength > 0) { //completionWindow.CompletionList.IsFiltering = false; completionWindow.CompletionList.SelectItem(results.TriggerWord); } completionWindow.Show(); completionWindow.Closed += (o, args) => completionWindow = null; } }//end if //update the insight window if (!string.IsNullOrEmpty(enteredText) && insightWindow != null) { //whenver text is entered update the provider var provider = insightWindow.Provider as CSharpOverloadProvider; if (provider != null) { //since the text has not been added yet we need to tread it as if the char has already been inserted var offset = 0; var doc = GetCompletionDocument(out offset); provider.Update(doc, offset); //if the windows is requested to be closed we do it here if (provider.RequestClose) { insightWindow.Close(); insightWindow = null; } } } }//end method
/// <summary> /// Constructor /// </summary> /// <param name="completionSet">Completion set</param> /// <param name="completion">Completion to classify</param> /// <param name="suffix">Text to classify</param> /// <param name="colorize">true if it should be colorized</param> public CompletionSuffixClassifierContext(CompletionSet completionSet, Completion completion, string suffix, bool colorize) : base(completionSet, completion, suffix, colorize) { }
public Task CancelAsync() { _cancellation.Cancel(); return(Completion.IgnoreExceptions()); }
public DuplexStreamingMethodCall(Func <ValueTask <IOutcomingInvocation <TRequest, TResponse> > > invocationFactory) { _invocationFactory = invocationFactory; Completion.LogCompletion(Log); }
public BestMatchSelector(string searchText) { if (searchText == null) throw new ArgumentNullException(nameof(searchText)); this.searchText = searchText; matchPriority = MatchPriority.Nothing; bestCompletion = null; acronymMatchIndexes = AcronymSearchHelpers.TryCreateMatchIndexes(searchText); }
public void Complete() { Completion.Start(); }
public Task<TimeSpan> TellParallel(int messageCount) { _tellParallel = true; _tellCount = 0; _tellExpected = messageCount; _tellTimer = Stopwatch.StartNew(); _tellCompletion = Context.GetCompletion<TimeSpan>(); var receiver = Context.Create<IPerfReceiver>().Proxy; for(var i = 0; i < messageCount; i++) { receiver.Tell(Guid.NewGuid(), "foo"); } return _tellCompletion; }
private string Resolve() { string value = null; var sheet = this.DataResolver.GetExcelSheet <Completion>(); Completion row = null; try { // try to get the row in the Completion table itself, because this is 'easiest' // The row may not exist at all (if the Key is for another table), or it could be the wrong row // (again, if it's meant for another table) row = sheet.GetRow(this.key); } catch { } // don't care, row will be null if (row?.Group == this.group) { // if the row exists in this table and the group matches, this is actually the correct data value = row.Text; } else { try { // we need to get the linked table and do the lookup there instead // in this case, there will only be one entry for this group id row = sheet.First(r => r.Group == this.group); // many of the names contain valid id ranges after the table name, but we don't need those var actualTableName = row.LookupTable.Split('[')[0]; var name = actualTableName switch { "Action" => this.DataResolver.GetExcelSheet <Lumina.Excel.GeneratedSheets.Action>().GetRow(this.key).Name, "ActionComboRoute" => this.DataResolver.GetExcelSheet <ActionComboRoute>().GetRow(this.key).Name, "BuddyAction" => this.DataResolver.GetExcelSheet <BuddyAction>().GetRow(this.key).Name, "ClassJob" => this.DataResolver.GetExcelSheet <ClassJob>().GetRow(this.key).Name, "Companion" => this.DataResolver.GetExcelSheet <Companion>().GetRow(this.key).Singular, "CraftAction" => this.DataResolver.GetExcelSheet <CraftAction>().GetRow(this.key).Name, "GeneralAction" => this.DataResolver.GetExcelSheet <GeneralAction>().GetRow(this.key).Name, "GuardianDeity" => this.DataResolver.GetExcelSheet <GuardianDeity>().GetRow(this.key).Name, "MainCommand" => this.DataResolver.GetExcelSheet <MainCommand>().GetRow(this.key).Name, "Mount" => this.DataResolver.GetExcelSheet <Mount>().GetRow(this.key).Singular, "Pet" => this.DataResolver.GetExcelSheet <Pet>().GetRow(this.key).Name, "PetAction" => this.DataResolver.GetExcelSheet <PetAction>().GetRow(this.key).Name, "PetMirage" => this.DataResolver.GetExcelSheet <PetMirage>().GetRow(this.key).Name, "PlaceName" => this.DataResolver.GetExcelSheet <PlaceName>().GetRow(this.key).Name, "Race" => this.DataResolver.GetExcelSheet <Race>().GetRow(this.key).Masculine, "TextCommand" => this.DataResolver.GetExcelSheet <TextCommand>().GetRow(this.key).Command, "Tribe" => this.DataResolver.GetExcelSheet <Tribe>().GetRow(this.key).Masculine, "Weather" => this.DataResolver.GetExcelSheet <Weather>().GetRow(this.key).Name, _ => throw new Exception(actualTableName) }; value = name; } catch (Exception e) { Log.Error(e, $"AutoTranslatePayload - failed to resolve: {this}"); } } return(value); }
FrameworkElement CreateFrameworkElement(Completion completion, CompletionClassifierKind kind) { if (completion == null) throw new ArgumentNullException(nameof(completion)); if (session.IsDismissed) return null; var completionSet = session.SelectedCompletionSet; if (completionSet == null) return null; Debug.Assert(completionSet.Completions.Contains(completion)); const bool colorize = true; return completionTextElementProvider.Create(completionSet, completion, kind, colorize); }
public void Add(Completion item) { this.listBox.Items.Add(item); }
private static bool IsVisible(Completion completion) { return ((DynamicallyVisibleCompletion)completion).Visible; }
private List <Completion> memberCompletion(ITextSnapshot snapshot, int start, int line, int column) { List <Completion> memberCompletion = new List <Completion>(); AstNode foundNode = null; //Replace '.' with ';' to avoid parse errors Span dotSpan = new Span(start, 1); snapshot = snapshot.TextBuffer.Delete(dotSpan); snapshot = snapshot.TextBuffer.Insert(dotSpan.Start, ";"); //StaDynParser parser = new StaDynParser(snapshot.TextBuffer, FileUtilities.Instance.getCurrentOpenDocumentFilePath()); //Parse source StaDynSourceFileAST parseResult;// = parser.parseSource(); StaDynParser parser = new StaDynParser(); parser.parseAll(); parseResult = ProjectFileAST.Instance.getAstFile(FileUtilities.Instance.getCurrentOpenDocumentFilePath()); //Replace ';' with '.' snapshot = snapshot.TextBuffer.Delete(dotSpan); snapshot = snapshot.TextBuffer.Insert(dotSpan.Start, "."); //parseResult = DecorateAST.Instance.completeDecorateAndUpdate(parseResult); if (parseResult == null || parseResult.Ast == null) { return(memberCompletion); } char previousChar = snapshot.GetText(start - 1, 1)[0]; column += 1; //Previous node is a MthodCall or Cast if (previousChar == ')') { //Start point is the ')', not the '.', so start-1 //foundNode = this.getCurrentInvocation(parseResult, snapshot, start - 1, line, column); foundNode = StaDynIntellisenseHelper.Instance.getCurrentInvocation(parseResult, snapshot, start - 1, line, column); if (!(foundNode is InvocationExpression) && !(foundNode is NewExpression)) { foundNode = this.getCurrentCast(parseResult, snapshot, start - 1, line, column); } } //Previous node is ArrayAcces else if (previousChar == ']') { foundNode = this.getCurrentArray(parseResult, snapshot, start, line, column); } else { //Node search //foundNode = (AstNode)parseResult.Ast.Accept(new VisitorFindNode(), new Location(Path.GetFileName(parseResult.FileName), line, column)); foundNode = (AstNode)parseResult.Ast.Accept(new VisitorFindNode(), new Location(parseResult.FileName, line, column)); } if (foundNode == null) { return(null); } TypeExpression type = (TypeExpression)foundNode.AcceptOperation(new GetNodeTypeOperation(), null); if (type == null) { return(null); } //Get the type members //double dispathcer pattern AccessModifier[] members = (AccessModifier[])type.AcceptOperation(new GetMembersOperation(), null); string displayName, description; bool duplicate = false; foreach (AccessModifier member in members) { duplicate = false; displayName = member.MemberIdentifier; description = displayName; if (member.Type != null) { //description = member.Type.FullName; description = member.Type.AcceptOperation(new GetTypeSystemName(), null) as string; if (String.IsNullOrEmpty(description)) { description = displayName; } } ImageSource image = CompletionGlyph.Instance.getImage(member.Type, this._glyphService); //Completion element = new Completion("." + displayName, "." + displayName, description, image, displayName); Completion element = new Completion(displayName, "." + displayName, description, image, displayName); //Avoid adding duplicate members foreach (Completion completion in memberCompletion) { if (completion.DisplayText == element.DisplayText) { if (completion.Description != description) { completion.Description += @" \/ " + description; } duplicate = true; break; } } if (!duplicate) { memberCompletion.Add(element); } //memberCompletion.Add(element); } //Sort the elements memberCompletion.Sort((x, y) => string.Compare(x.DisplayText, y.DisplayText)); //Remove duplicates //List<Completion> unique = new List<Completion>(memberCompletion.Distinct<Completion>(new CompletionComparer())); return(memberCompletion); }
void CmdTabOrComplete() { bool complete = false; if (AutoCompleteEvent != null) { if (TabAtStartCompletes) { complete = true; } else { for (int i = 0; i < cursor; i++) { if (!Char.IsWhiteSpace(text[i])) { complete = true; break; } } } if (complete) { Completion completion = AutoCompleteEvent(text.ToString(), cursor); string[] completions = completion.Result; if (completions == null) { return; } int ncompletions = completions.Length; if (ncompletions == 0) { return; } if (completions.Length == 1) { InsertTextAtCursor(completions[0]); } else { int last = -1; for (int p = 0; p < completions[0].Length; p++) { char c = completions[0][p]; for (int i = 1; i < ncompletions; i++) { if (completions[i].Length < p) { goto mismatch; } if (completions[i][p] != c) { goto mismatch; } } last = p; } mismatch: if (last != -1) { InsertTextAtCursor(completions[0].Substring(0, last + 1)); } Console.WriteLine(); foreach (string s in completions) { Console.Write(completion.Prefix); Console.Write(s); Console.Write(' '); } Console.WriteLine(); Render(); ForceCursor(cursor); } } else { HandleChar('\t'); } } else { HandleChar('t'); } }
bool CompleteCompletionSession(char ch) { if (_completionSession == null) { return(false); } bool commit = false; bool moveBack = false; Completion completion = null; XSCompletion xscompletion = null; ITextCaret caret = null; WriteOutputMessage("CompleteCompletionSession()"); if (_completionSession.SelectedCompletionSet != null) { bool addDelim = false; if (_completionSession.SelectedCompletionSet.SelectionStatus.Completion != null) { completion = _completionSession.SelectedCompletionSet.SelectionStatus.Completion; } xscompletion = completion as XSCompletion; Kind kind = Kind.Unknown; if (xscompletion != null) { kind = xscompletion.Kind; } bool ctor = false; // some tokens need to be added to the insertion text. switch (kind) { case Kind.Keyword: formatKeyword(completion); break; case Kind.Class: case Kind.Structure: case Kind.Constructor: ctor = true; goto default; default: switch (ch) { case '{' when ctor: case '}' when ctor: if (!completion.InsertionText.EndsWith("{")) { completion.InsertionText += "{"; } break; case '\t': // Tab case '\r': // CR case '\n': // CR case '.': // DOT case ':': // COLON case '\0': break; default: var s = ch.ToString(); if (!completion.InsertionText.EndsWith(s)) { completion.InsertionText += s; } break; } break; } if ((_completionSession.SelectedCompletionSet.Completions.Count > 0) && (_completionSession.SelectedCompletionSet.SelectionStatus.IsSelected)) { if (XSettings.EditorCompletionAutoPairs) { caret = _completionSession.TextView.Caret; addDelim = true; WriteOutputMessage(" --> select " + completion.InsertionText); if (kind == Kind.Constructor) { completion.InsertionText += "{"; } else if (kind.HasParameters() && !completion.InsertionText.EndsWith("(")) { completion.InsertionText += "("; } } commit = true; } else { if (completion != null) { // Push the completion char into the InsertionText if needed if (!completion.InsertionText.EndsWith(ch.ToString())) { completion.InsertionText += ch; } if (XSettings.EditorCompletionAutoPairs) { caret = _completionSession.TextView.Caret; addDelim = true; } } commit = true; } if (addDelim) { if (completion.InsertionText.EndsWith("(")) { moveBack = true; completion.InsertionText += ")"; } else if (completion.InsertionText.EndsWith("{")) { moveBack = true; completion.InsertionText += "}"; } else if (completion.InsertionText.EndsWith("[")) { moveBack = true; completion.InsertionText += "]"; } } } if (commit) { WriteOutputMessage(" --> Commit"); var session = _completionSession; session.Properties.TryGetProperty(XsCompletionProperties.Type, out IXTypeSymbol type); string insertionText = completion.InsertionText; session.Properties.TryGetProperty(XsCompletionProperties.Char, out char triggerChar); if (ch == '.' || ch == ':') { if (insertionText.IndexOfAny("({".ToCharArray()) == -1) { completion.InsertionText += ch; } } _completionSession.Commit(); if (moveBack && (caret != null)) { caret.MoveToPreviousCaretPosition(); } // if a method or constructor was chosen, then trigger the signature help if (insertionText.Contains('(') || insertionText.Contains('{')) { TriggerSignatureHelp(type, insertionText, triggerChar); } return(true); } WriteOutputMessage(" --> Dismiss"); _completionSession.Dismiss(); return(false); }
void SelectItem(Completion completionItem) { TheCompletionsCollectionView.MoveCurrentTo(completionItem); }
void formatKeyword(Completion completion) { completion.InsertionText = XSettings.FormatKeyword(completion.InsertionText); }
public Task<Tuple<double, TimeSpan>> Start() { if(_completion != null) { throw new Exception("accumulator already started"); } _t = Stopwatch.StartNew(); _completion = Context.GetCompletion<Tuple<double, TimeSpan>>(); return _completion; }
private void CommentBuilder(Comment result) { _asyncCommentResult = result; Completion.Set(); }
/// <summary> /// Constructor /// </summary> /// <param name="completionSet">Completion set</param> /// <param name="completion">Completion to classify</param> /// <param name="text">Text to classify</param> /// <param name="colorize">true if it should be colorized</param> protected CompletionClassifierContext(CompletionSet completionSet, Completion completion, string text, bool colorize) : base(text, string.Empty, colorize) { CompletionSet = completionSet ?? throw new ArgumentNullException(nameof(completionSet)); Completion = completion ?? throw new ArgumentNullException(nameof(completion)); }
public override async Task <Completion> WriteToAsync(TextWriter writer, TextEncoder encoder, TemplateContext context) { if (!context.AmbientValues.TryGetValue("Services", out var servicesValue)) { throw new ArgumentException("Services missing while invoking 'helper'"); } var services = servicesValue as IServiceProvider; if (!context.AmbientValues.TryGetValue("ViewContext", out var viewContext)) { throw new ArgumentException("ViewContext missing while invoking 'helper'"); } var arguments = (FilterArguments)(await _arguments.EvaluateAsync(context)).ToObjectValue(); var helper = _helper ?? arguments.At(0).ToStringValue(); var tagHelperSharedState = services.GetRequiredService <TagHelperSharedState>(); if (tagHelperSharedState.TagHelperDescriptors == null) { lock (tagHelperSharedState) { if (tagHelperSharedState.TagHelperDescriptors == null) { var razorEngine = services.GetRequiredService <RazorEngine>(); var tagHelperFeature = razorEngine.Features.OfType <ITagHelperFeature>().FirstOrDefault(); tagHelperSharedState.TagHelperDescriptors = tagHelperFeature.GetDescriptors().ToList(); } } } if (_descriptor == null) { lock (this) { var descriptors = tagHelperSharedState.TagHelperDescriptors .Where(d => d.TagMatchingRules.Any(rule => ((rule.TagName == "*") || rule.TagName == helper) && rule.Attributes.All(attr => arguments.Names.Any(name => { if (String.Equals(name, attr.Name, StringComparison.OrdinalIgnoreCase)) { return(true); } name = name.Replace("_", "-"); if (attr.Name.StartsWith(AspPrefix) && String.Equals(name, attr.Name.Substring(AspPrefix.Length), StringComparison.OrdinalIgnoreCase)) { return(true); } if (String.Equals(name, attr.Name, StringComparison.OrdinalIgnoreCase)) { return(true); } return(false); })))); _descriptor = descriptors.FirstOrDefault(); if (_descriptor == null) { return(Completion.Normal); } } } var tagHelperType = Type.GetType(_descriptor.Name + ", " + _descriptor.AssemblyName); var _tagHelperActivator = _tagHelperActivators.GetOrAdd(tagHelperType, key => { var genericFactory = typeof(ReusableTagHelperFactory <>).MakeGenericType(key); var factoryMethod = genericFactory.GetMethod("CreateTagHelper"); return(Delegate.CreateDelegate(typeof(Func <ITagHelperFactory, ViewContext, ITagHelper>), factoryMethod) as Func <ITagHelperFactory, ViewContext, ITagHelper>); }); var tagHelperFactory = services.GetRequiredService <ITagHelperFactory>(); var tagHelper = _tagHelperActivator(tagHelperFactory, (ViewContext)viewContext); var attributes = new TagHelperAttributeList(); foreach (var name in arguments.Names) { var propertyName = LiquidViewFilters.LowerKebabToPascalCase(name); var found = false; foreach (var attribute in _descriptor.BoundAttributes) { if (propertyName == attribute.GetPropertyName()) { found = true; var setter = _tagHelperSetters.GetOrAdd(attribute.DisplayName, key => { var propertyInfo = tagHelperType.GetProperty(propertyName); var propertySetter = propertyInfo.GetSetMethod(); var invokeType = typeof(Action <,>).MakeGenericType(tagHelperType, propertyInfo.PropertyType); var setterDelegate = Delegate.CreateDelegate(invokeType, propertySetter); Action <ITagHelper, FluidValue> result = (h, v) => { object value = null; if (attribute.IsEnum) { value = Enum.Parse(propertyInfo.PropertyType, v.ToStringValue()); } else if (attribute.IsStringProperty) { value = v.ToStringValue(); } else if (propertyInfo.PropertyType == typeof(Boolean)) { value = Convert.ToBoolean(v.ToStringValue()); } else { value = v.ToObjectValue(); } setterDelegate.DynamicInvoke(new[] { h, value }); }; return(result); }); try { setter(tagHelper, arguments[name]); } catch (ArgumentException e) { throw new ArgumentException("Incorrect value type assigned to a tag.", name, e); } break; } } if (!found) { attributes.Add(new TagHelperAttribute(name.Replace("_", "-"), arguments[name].ToObjectValue())); } } var content = new StringWriter(); if (Statements?.Any() ?? false) { Completion completion = Completion.Break; for (var index = 0; index < Statements.Count; index++) { completion = await Statements[index].WriteToAsync(content, encoder, context); if (completion != Completion.Normal) { return(completion); } } } var tagHelperContext = new TagHelperContext(attributes, new Dictionary <object, object>(), Guid.NewGuid().ToString("N")); var tagHelperOutput = new TagHelperOutput(helper, attributes, (_, e) => Task.FromResult(new DefaultTagHelperContent().AppendHtml(content.ToString()))); tagHelperOutput.Content.AppendHtml(content.ToString()); await tagHelper.ProcessAsync(tagHelperContext, tagHelperOutput); tagHelperOutput.WriteTo(writer, HtmlEncoder.Default); return(Completion.Normal); }
public static CompletionVM TryGet(Completion completion) { if (completion == null) return null; CompletionVM vm; if (completion.Properties.TryGetProperty(typeof(CompletionVM), out vm)) return vm; return null; }
public static int CompareOrdinal(Completion completion1, Completion completion2) { return(Compare(completion1, completion2, StringComparison.Ordinal)); }
MatchPriority GetMatchPriority(Completion completion) { var filterText = completion.TryGetFilterText(); Debug.Assert(filterText != null); if (filterText == null) return MatchPriority.Other; if (filterText.Equals(searchText, StringComparison.CurrentCulture)) return MatchPriority.Full; bool matchedAcronym = acronymMatchIndexes != null && AcronymSearchHelpers.TryUpdateAcronymIndexes(acronymMatchIndexes, searchText, filterText); if (matchedAcronym && CountUpperCaseLetters(filterText) == acronymMatchIndexes.Length) return MatchPriority.FullAcronym; if (filterText.Equals(searchText, StringComparison.CurrentCultureIgnoreCase)) return MatchPriority.FullIgnoringCase; int index = filterText.IndexOf(searchText, StringComparison.CurrentCulture); if (index == 0) return MatchPriority.Start; if (matchedAcronym && acronymMatchIndexes[0] == 0) return MatchPriority.StartAcronym; int indexIgnoringCase = filterText.IndexOf(searchText, StringComparison.CurrentCultureIgnoreCase); if (indexIgnoringCase == 0) return MatchPriority.StartIgnoringCase; if (index > 0) return MatchPriority.AnyLocation; if (matchedAcronym) return MatchPriority.AnyLocationAcronym; if (indexIgnoringCase > 0) return MatchPriority.AnyLocationIgnoringCase; return MatchPriority.Other; }
public static int CompareIgnoreCase(Completion completion1, Completion completion2) { return(Compare(completion1, completion2, StringComparison.OrdinalIgnoreCase)); }
protected abstract void CommitCore(DothtmlCompletionContext context, Completion completion);
private void TrackListBuilder(List <Track> result) { _asyncTracksResult = result; Completion.Set(); }
public Task SignalCounter(int count) { _counter = count; _completion = Context.GetCompletion(); return _completion; }
void Awake() { DontDestroyOnLoad(transform.gameObject); instance = this; }
public Task<TimeSpan> TellSequential(int messageCount) { _tellParallel = false; _tellCount = 0; _tellExpected = messageCount; _tellTimer = Stopwatch.StartNew(); _tellCompletion = Context.GetCompletion<TimeSpan>(); _tellReceiver = Context.Create<IPerfReceiver>().Proxy; _tellReceiver.Tell(Guid.NewGuid(), "foo"); return _tellCompletion; }
private bool IsAdvanced(Completion comp) { return(_advancedItemPattern.IsMatch(_matchInsertionText ? comp.InsertionText : comp.DisplayText)); }
CompletionVM GetExistingCompletionVM(Completion completion) { if (completion == null) return null; var vm = CompletionVM.TryGet(completion); Debug.Assert(vm != null); return vm; }
private static bool IsVisible(Completion completion) { return(((DynamicallyVisibleCompletion)completion).Visible); }
CompletionVM GetOrCreateVM(Completion completion) => CompletionVM.TryGet(completion) ?? new CompletionVM(completion, imageMonikerService);
private Completion ArrayAccumulate(ArrayObject array, int nextIndex) { foreach (var item in arrayLiteralItems) { Completion valueComp; BooleanCompletion status; IValue value; switch (item) { case AbstractAssignmentExpression assignmentExpression: valueComp = assignmentExpression.Evaluate(Interpreter.Instance()).GetValue(); if (valueComp.IsAbrupt()) { return(valueComp); } value = valueComp.value !; status = Utils.CreateDataProperty(array, nextIndex.ToString(System.Globalization.CultureInfo.InvariantCulture), value); if (status.IsAbrupt() || !status.Other) { throw new InvalidOperationException("Spec 12.2.5.2, Assignment, step 5"); } nextIndex++; break; case Elision elision: nextIndex += elision.width; break; case SpreadElement spreadElement: valueComp = spreadElement.assignmentExpression.Evaluate(Interpreter.Instance()).GetValue(); if (valueComp.IsAbrupt()) { return(valueComp); } value = valueComp.value !; if (!(value is Object @object)) { throw new InvalidOperationException($"ArrayLiteral: tried to initialize an array using a spread on a non-object"); } var iteratorComp = @object.GetIterator(); if (iteratorComp.IsAbrupt()) { return(iteratorComp); } var iteratorRecord = iteratorComp.Other !; while (true) { var next = iteratorRecord.IteratorStep(); if (next.IsAbrupt()) { return(next); } if (next.value == BooleanValue.False) { break; } var nextValue = IteratorRecord.IteratorValue(next.value !); if (nextValue.IsAbrupt()) { return(nextValue); } status = Utils.CreateDataProperty(array, nextIndex.ToString(System.Globalization.CultureInfo.InvariantCulture), nextValue.value !); if (status.IsAbrupt() || !status.Other) { throw new InvalidOperationException("Spec 12.2.5.2, Spread, step 4e"); } nextIndex++; } break; } } return(Completion.NormalCompletion(new NumberValue(nextIndex))); }
private bool IsAdvanced(Completion comp) { return _advancedItemPattern.IsMatch(_matchInsertionText ? comp.InsertionText : comp.DisplayText); }
internal CompletionAwaiter(Task task, Completion parent) { _parent = parent; _taskAwaiter = task.GetAwaiter(); }
/// <summary> /// Determines the best match in the completion set. /// </summary> public override void SelectBestMatch() { var text = ApplicableTo.GetText(ApplicableTo.TextBuffer.CurrentSnapshot); Completion bestMatch = _previousSelection; int bestValue = 0; bool isUnique = true; bool allowSelect = true; // Using the Completions property to only search through visible // completions. foreach (var comp in Completions) { int value = _comparer.GetSortKey(_matchInsertionText ? comp.InsertionText : comp.DisplayText, text); if (bestMatch == null || value > bestValue) { bestMatch = comp; bestValue = value; isUnique = true; } else if (value == bestValue) { isUnique = false; } } if (Moniker == "PythonOverrides") { allowSelect = false; isUnique = false; } if (((DynamicallyVisibleCompletion)bestMatch).Visible) { SelectionStatus = new CompletionSelectionStatus( bestMatch, isSelected: allowSelect && bestValue > 0, isUnique: isUnique ); } else { SelectionStatus = new CompletionSelectionStatus( null, isSelected: false, isUnique: false ); } _previousSelection = bestMatch; }
/// <summary> /// Constructor. /// </summary> public SubmissionStatus(Completion completion, bool late) { Completion = completion; Late = late; }