void CreateAndAddAdornment(ITextViewLine line, SnapshotSpan span, Brush brush, bool extendToRight) { var markerGeometry = _view.TextViewLines.GetMarkerGeometry(span); double left = 0; double width = _view.ViewportWidth + _view.MaxTextRightCoordinate; if (markerGeometry != null) { left = markerGeometry.Bounds.Left; if (!extendToRight) width = markerGeometry.Bounds.Width; } Rect rect = new Rect(left, line.Top, width, line.Height); RectangleGeometry geometry = new RectangleGeometry(rect); GeometryDrawing drawing = new GeometryDrawing(brush, new Pen(), geometry); drawing.Freeze(); DrawingImage drawingImage = new DrawingImage(drawing); drawingImage.Freeze(); Image image = new Image(); image.Source = drawingImage; Canvas.SetLeft(image, geometry.Bounds.Left); Canvas.SetTop(image, geometry.Bounds.Top); _layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, null); }
public IEnumerable<SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken) { var span = new SnapshotSpan(_view.Selection.Start.Position, _view.Selection.End.Position); var startLine = span.Start.GetContainingLine().Extent; var endLine = span.End.GetContainingLine().Extent; var selectionStart = _view.Selection.Start.Position.Position; var selectionEnd = _view.Selection.End.Position.Position; var SelectedSpan = new SnapshotSpan(span.Snapshot, selectionStart, selectionEnd - selectionStart); var list = new List<SuggestedActionSet>(); if (!_view.Selection.IsEmpty && startLine == endLine) { var convertToLink = new ConvertToLinkAction(SelectedSpan, _view); var convertToImage = new ConvertToImageAction(SelectedSpan, _file); list.AddRange(CreateActionSet(convertToLink, convertToImage)); } var convertToQuote = new ConvertToQuoteAction(SelectedSpan, _view); var convertToCodeBlock = new ConvertToCodeBlockAction(SelectedSpan, _view); list.AddRange(CreateActionSet(convertToQuote, convertToCodeBlock)); return list; }
public void ExtendToFullLineIncludingLineBreak2() { Create("dog", "cat", "chicken", "pig"); var span = new SnapshotSpan(_buffer.GetLine(1).Start, 0); span = SnapshotSpanUtil.ExtendToFullLineIncludingLineBreak(span); Assert.AreEqual(_buffer.GetLineRange(1).ExtentIncludingLineBreak, span); }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { List<ClassificationSpan> spans = new List<ClassificationSpan>(); if (!WESettings.GetBoolean(WESettings.Keys.SyncVendorValues) || !EnsureInitialized()) return spans; var declarations = Cache.Where(d => span.End <= d.AfterEnd && d.Start >= span.Start); foreach (Declaration dec in Cache.Where(d => d.PropertyName.Text.Length > 0 && span.Snapshot.Length >= d.AfterEnd)) { if (dec.IsVendorSpecific()) { var ss = new SnapshotSpan(span.Snapshot, dec.Start, dec.Length); var s = new ClassificationSpan(ss, _decClassification); spans.Add(s); } int start = dec.Colon.AfterEnd; int length = dec.AfterEnd - start; if (span.Snapshot.Length > start + length) { var ss2 = new SnapshotSpan(span.Snapshot, start, length); var s2 = new ClassificationSpan(ss2, _valClassification); spans.Add(s2); } } return spans; }
public Task<bool> HasSuggestedActionsAsync(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken) { return Task.Factory.StartNew(() => { return !_view.Selection.IsEmpty; }); }
public void AddDecorationError(BasePropertyDeclarationSyntax _property, string textFull, string toolTipText, FixErrorCallback errorCallback) { var lineSpan = tree.GetLineSpan(_property.Span, usePreprocessorDirectives: false); int lineNumber = lineSpan.StartLinePosition.Line; var line = _textView.TextSnapshot.GetLineFromLineNumber(lineNumber); var textViewLine = _textView.GetTextViewLineContainingBufferPosition(line.Start); int startSpace = textFull.Length - textFull.TrimStart().Length; int endSpace = textFull.Length - textFull.TrimEnd().Length; SnapshotSpan span = new SnapshotSpan(_textView.TextSnapshot, Span.FromBounds(line.Start.Position + startSpace, line.End.Position - endSpace)); Geometry g = _textView.TextViewLines.GetMarkerGeometry(span); if (g != null) { rects.Add(g.Bounds); GeometryDrawing drawing = new GeometryDrawing(_brush, _pen, g); drawing.Freeze(); DrawingImage drawingImage = new DrawingImage(drawing); drawingImage.Freeze(); Image image = new Image(); image.Source = drawingImage; //image.Visibility = Visibility.Hidden; Canvas.SetLeft(image, g.Bounds.Left); Canvas.SetTop(image, g.Bounds.Top); _layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, (t, ui) => { rects.Remove(g.Bounds); }); DrawIcon(span, g.Bounds.Left - 30, g.Bounds.Top, toolTipText, errorCallback); } }
protected void EnterSelect(int start, int length) { var span = new SnapshotSpan(_textBuffer.CurrentSnapshot, start, length); _textView.SelectAndMoveCaret(span); _context.RunAll(); Assert.Equal(ModeKind.SelectCharacter, _vimBuffer.ModeKind); }
public IEnumerable<SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken) { return ( // code fixes from tagSpan in _aggregator.GetTags(range) where tagSpan.Tag is DiagnosticErrorTag let diagnostic = tagSpan.Tag as DiagnosticErrorTag from provider in _codeFixProviders where provider.CanFix(diagnostic.Id) let span = tagSpan.Span.GetSpans(_buffer).First() from fix in provider.GetFixes(span) group fix by provider into set where set.Any() select set as IEnumerable<CodeAction> ).Union( // code refactorings from provider in _refactoringProviders from refactoring in provider.GetRefactorings(range) group refactoring by provider into set where set.Any() select set as IEnumerable<CodeAction> ) .Select(s => s.Select(ca => ca.ToSuggestedAction())) .Select(s => new SuggestedActionSet(s)) ; }
private void ToggleCurrent() { var caretPosition = _textView.Caret.Position.BufferPosition; var snapshot = _textView.TextBuffer.CurrentSnapshot; var span = new SnapshotSpan(snapshot, new Span(caretPosition, 0)); var regions = OutliningManager.GetAllRegions(span); // Find innermost one ICollapsible region = null; int regionStart = 0; int regionEnd = snapshot.Length; foreach (ICollapsible c in regions) { int start = c.Extent.GetStartPoint(snapshot); int end = c.Extent.GetEndPoint(snapshot); if (start >= regionStart && end < regionEnd) { regionStart = start; regionEnd = end; region = c; } } if (region != null) { if (region.IsCollapsed) OutliningManager.Expand(region as ICollapsed); else OutliningManager.TryCollapse(region); } }
public TranslationAdornment(SnapshotSpan span, TranslationRequest request, Size viewportSize) { Span = span.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive); Request = request; Request.TranslationComplete += request_TranslationComplete; InitializeComponent(); DataContext = this; SetMaxSize(viewportSize); _menu = spListBox.ContextMenu; _menu.KeyUp += (sender, args) => { if (args.Key == Key.Left || args.Key == Key.Escape) { CloseMenu(); } }; _menu.Opened += (sender, args) => { _closeMenuRequested = false; }; _menu.Closed += (sender, args) => { _ignoreItemCommand = !_closeMenuRequested; }; ItemCommand = new RelayCommand<ItemCommandParameter>(ItemCommandExecute); ItemOptionsCommand = new RelayCommand<ItemCommandParameter>(ItemOptionsCommandExecute); MenuCommand = new RelayCommand<MenuItem>(MenuCommandExecute); }
private IList<ClassificationSpan> DoGetClassificationSpans(SnapshotSpan span) { List<ClassificationSpan> spans = null; object prop; if (span.Snapshot.TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out prop)) { var doc = (ITextDocument)prop; string fileName = System.IO.Path.GetFileName(doc.FilePath); Language lang = Languages.FindLanguage(fileName); if (lang != null) { List<ClassificationSpan> strings = new List<ClassificationSpan>(); List<ClassificationSpan> comments = new List<ClassificationSpan>(); DoGetStringSpans(lang, span, strings, comments); spans = new List<ClassificationSpan>(); if (!strings.Any(s => s.Span.Contains(span) && !comments.Any(t => t.Span.Contains(span)))) { IEnumerable<ClassificationSpan> mine = lang.GetClassificationSpans(span); spans.AddRange(from c in mine where !strings.Any(d => d.Span.OverlapsWith(c.Span)) && !comments.Any(d => d.Span.OverlapsWith(c.Span)) select c); } spans.AddRange(strings); spans.AddRange(comments); } } return spans ?? ms_noSpans; }
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); } }
private static int CalculateDeletionEndFromRuleEndPosition(ITextSnapshot snapshot, int endPosition) { var position = endPosition; var committedPosition = position; while (true) { if (position < snapshot.Length) { var ss = new SnapshotSpan(snapshot, position, 1); var text = ss.GetText(); if (text != null) { if ("\r\n".Contains(text)) { committedPosition = ++position; continue; } if (string.IsNullOrWhiteSpace(text)) { ++position; continue; } } } return committedPosition; } }
public ReplSpan(bool wasCommand, bool wasException, SnapshotSpan input, SnapshotSpan? output) { WasCommand = wasCommand; WasException = wasException; Input = input; Output = output; }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { IList<ClassificationSpan> list = new List<ClassificationSpan>(); if (!_isRobotsTxt) return list; string text = span.GetText(); int index = text.IndexOf("#"); if (index > -1) { var result = new SnapshotSpan(span.Snapshot, span.Start + index, text.Length - index); list.Add(new ClassificationSpan(result, _comment)); } if (index == -1 || index > 0) { string[] args = text.Split(':'); if (args.Length >= 2 && _valid.Contains(args[0].Trim().ToLowerInvariant())) { var result = new SnapshotSpan(span.Snapshot, span.Start, args[0].Length); list.Add(new ClassificationSpan(result, _keyword)); } } return list; }
internal ExternalEditMarker( ExternalEditKind kind, SnapshotSpan span) { ExternalEditKind = kind; Span = span; }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { if (fileNode != null) return fileNode.GetClassificationSpans(span); return new List<ClassificationSpan>(); }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { List<ClassificationSpan> spans = new List<ClassificationSpan>(); if (!WESettings.Instance.Css.SyncBase64ImageValues) return spans; foreach (Declaration dec in Cache.Where(d => d.PropertyName.Text.EndsWith("background-image", StringComparison.OrdinalIgnoreCase) && span.Start <= d.Start && span.End >= d.AfterEnd)) { if (dec.PropertyName.Text.StartsWith("*background", StringComparison.OrdinalIgnoreCase)) { var ss = new SnapshotSpan(span.Snapshot, dec.Start, dec.Length); var s = new ClassificationSpan(ss, _decClassification); spans.Add(s); } if (dec.Semicolon == null) continue; int start = dec.Colon.AfterEnd; int length = dec.AfterEnd - start; if (span.Snapshot.Length > start + length) { var ss2 = new SnapshotSpan(span.Snapshot, start, length); var s2 = new ClassificationSpan(ss2, _valClassification); spans.Add(s2); } } return spans; }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { try { var spans = new List<ClassificationSpan>(); var snapshot = span.Snapshot; if (snapshot == null || snapshot.Length == 0) { return spans; } LoadSettings(); var start = span.Start.GetContainingLine().LineNumber; var end = (span.End - 1).GetContainingLine().LineNumber; for (var i = start; i <= end; i++) { var line = snapshot.GetLineFromLineNumber(i); var snapshotSpan = new SnapshotSpan(line.Start, line.Length); var text = line.Snapshot.GetText(snapshotSpan); if (string.IsNullOrEmpty(text) == false) { var classificationName = _classifiers.First(classifier => classifier.Test(text)).Type; var type = _classificationTypeRegistry.GetClassificationType(classificationName); spans.Add(new ClassificationSpan(line.Extent, type)); } } return spans; } catch (Exception ex) { LogError(ex.ToString()); throw; } }
/// <summary> /// Classify the given spans /// </summary> /// <param name="span">The span of interest in this projection buffer.</param> /// <returns>The list of <see cref="ClassificationSpan"/> as contributed by the source buffers.</returns> public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { ITextSnapshot snapshot = span.Snapshot; List<ClassificationSpan> spans = new List<ClassificationSpan>(); if (snapshot.Length == 0) return spans; var text = span.GetText(); if (text.StartsWith("System.Windows.Data Error", StringComparison.OrdinalIgnoreCase)) { IClassificationType type = _classificationTypeRegistry.GetClassificationType("output.wpfbindingalert"); spans.Add(new ClassificationSpan(span, type)); } else if (text.IndexOf("error ", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("error:", StringComparison.OrdinalIgnoreCase) >= 0) { //error followed by a space is the typical error of the build. IClassificationType type = _classificationTypeRegistry.GetClassificationType("output.alert"); spans.Add(new ClassificationSpan(span, type)); } else if (text.IndexOf("INFO:", StringComparison.OrdinalIgnoreCase) >= 0) { //error followed by a space is the typical error of the build. IClassificationType type = _classificationTypeRegistry.GetClassificationType("output.info"); spans.Add(new ClassificationSpan(span, type)); } return spans; }
// This does not work properly for multiline fenced code-blocks, // since we get each line separately. If I can assume that this // always runs sequentially without skipping, I can add state to // track whether we're in a fenced block. public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { string text = span.GetText(); var codeBlocks = FindMatches(span, text, _reCode, _code).ToList(); if (codeBlocks.Any()) { // Flatten all code blocks to avoid matching text within them var nonCodeBuilder = text.ToCharArray(); foreach (var code in codeBlocks) { for (int i = code.Span.Start; i < code.Span.End; i++) { nonCodeBuilder[i - span.Start] = 'Q'; } } text = new String(nonCodeBuilder); } var quotes = FindMatches(span, text, _reQuote, _quote); var bolds = FindMatches(span, text, _reBold, _bold); var italics = FindMatches(span, text, _reItalic, _italic); var headers = FindMatches(span, text, _reHeader, _header); return bolds.Concat(italics).Concat(headers).Concat(codeBlocks).Concat(quotes).ToList(); }
/// <summary> /// Within the given line add the scarlet box behind the a /// </summary> private void CreateVisuals(ITextViewLine line) { //grab a reference to the lines in the current TextView IWpfTextViewLineCollection textViewLines = _view.TextViewLines; int start = line.Start; int end = line.End; //Loop through each character, and place a box around any a for (int i = start; (i < end); ++i) { if (_view.TextSnapshot[i] == 'a') { SnapshotSpan span = new SnapshotSpan(_view.TextSnapshot, Span.FromBounds(i, i + 1)); Geometry g = textViewLines.GetMarkerGeometry(span); if (g != null) { GeometryDrawing drawing = new GeometryDrawing(_brush, _pen, g); drawing.Freeze(); DrawingImage drawingImage = new DrawingImage(drawing); drawingImage.Freeze(); Image image = new Image(); image.Source = drawingImage; //Align the image with the top of the bounds of the text geometry Canvas.SetLeft(image, g.Bounds.Left); Canvas.SetTop(image, g.Bounds.Top); _layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, null); } } } }
/// <summary> /// Is the current selection that of the C# event add pattern? /// </summary> internal bool IsEventAddSelection(ITextView textView) { var textSelection = textView.Selection; if (textSelection.IsEmpty || textSelection.Mode != TextSelectionMode.Stream) { return false; } var span = textView.Selection.StreamSelectionSpan.SnapshotSpan; var lineRange = SnapshotLineRangeUtil.CreateForSpan(span); if (lineRange.Count != 1) { return false; } // Include the character after the selection. Needed to disambiguate a couple // of cases var endPoint = span.End; if (endPoint.Position < lineRange.End.Position) { endPoint = endPoint.Add(1); } var beforeSpan = new SnapshotSpan(lineRange.Start, endPoint); return IsPreceededByEventAddSyntax(beforeSpan); }
private IEnumerable<SnapshotSpan> GetAllTags() { var snapshot = _textView.TextBuffer.CurrentSnapshot; var snapshotSpan = new SnapshotSpan(snapshot, 0, snapshot.Length); var tags = GetTags(snapshotSpan); return tags; }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { IList<ClassificationSpan> spans = new List<ClassificationSpan>(); string text = span.GetText(); int index = text.IndexOf("#", StringComparison.Ordinal); if (index > -1) { var result = new SnapshotSpan(span.Snapshot, span.Start + index, text.Length - index); spans.Add(new ClassificationSpan(result, comment)); } if (index == -1 || index > 0) { var trimmed = text.TrimStart(); var offset = text.Length - trimmed.Length; string[] args = trimmed.Split(' '); if (args.Length >= 2 && ValidKeywords.Contains(args[0].Trim().ToLowerInvariant())) { var result = new SnapshotSpan(span.Snapshot, span.Start + offset, args[0].Trim().Length); spans.Add(new ClassificationSpan(result, keyword)); } } return spans; }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { var results = new List<ClassificationSpan>(); var snapshot = Buffer.CurrentSnapshot; var stylesheet = Editor.Document.Stylesheet; if (stylesheet != null) { try { foreach (var current in GetItems(stylesheet.Children, span)) { if (current.Start > span.End) break; var type = ClassifierContextCache.Get(current.ClassifierType).GetClassification(Registry); if (type == null) continue; var start = Math.Max(0, current.Start); var length = Math.Min(snapshot.Length - start, current.Length); results.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(start, length)), type)); } } catch (Exception ex) { Logger.Log(ex, "Failed to classify"); } } return results; }
private static int CalculateDeletionStartFromStartPosition(ITextSnapshot snapshot, int startPosition) { var position = startPosition - 1; if (position < 0) { return 0; } while (true) { if (position > 0) { var ss = new SnapshotSpan(snapshot, position, 1); var text = ss.GetText(); if (text != null && !"\r\n".Contains(text) && string.IsNullOrWhiteSpace(text)) { --position; continue; } ++position; } return position; } }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { var result = new List<ClassificationSpan>(); var semanticModelResult = SemanticModelService.SemanticModelResult; if(semanticModelResult == null) { return result; } var classificationType = ClassificationTypeRegistryService.GetClassificationType(ClassificationTypeNames.DeadCode); var extent = TextExtent.FromBounds(span.Start.Position, span.End.Position); var diagnostics = semanticModelResult.CompilationUnit.Diagnostics; var candidates = diagnostics.Where(diagnostic => diagnostic.Category == DiagnosticCategory.DeadCode) .Where(d => d.Location.Extent.IntersectsWith(extent)); foreach (var diagnostic in candidates) { var diagnosticSpan = new SnapshotSpan(semanticModelResult.Snapshot, new Span(diagnostic.Location.Start, diagnostic.Location.Length)); var classification = new ClassificationSpan( diagnosticSpan.TranslateTo(span.Snapshot, SpanTrackingMode.EdgeExclusive), classificationType); result.Add(classification); } return result; }
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { IList<ClassificationSpan> list = new List<ClassificationSpan>(); string text = span.GetText(); if (text.StartsWith("/// <binding")) { foreach (Match match in _binding.Matches(text)) { var value = match.Groups["value"]; var result = new SnapshotSpan(span.Snapshot, span.Start + value.Index, value.Length); list.Add(new ClassificationSpan(result, _formatDefinition)); } } else { int index = text.IndexOf(_searchText, StringComparison.Ordinal); if (index == -1) return list; foreach (Match match in _task.Matches(text)) { var name = match.Groups["name"]; var result = new SnapshotSpan(span.Snapshot, span.Start + name.Index, name.Length); list.Add(new ClassificationSpan(result, _formatDefinition)); } } return list; }
/// <summary> /// Is the provided SnapshotPoint preceded by the '+= SomeEventType(Some_HandlerName' line /// </summary> private bool IsPreceededByEventAddSyntax(SnapshotSpan span) { // First find the last + character var snapshot = span.Snapshot; SnapshotPoint? plusPoint = null; for (int i = span.Length - 1; i >= 0; i--) { var position = span.Start.Position + i; var point = new SnapshotPoint(snapshot, position); if (point.GetChar() == '+') { plusPoint = point; break; } } if (plusPoint == null) { return false; } var eventSpan = new SnapshotSpan(plusPoint.Value, span.End); var eventText = eventSpan.GetText(); return s_fullEventSyntaxRegex.IsMatch(eventText) || s_shortEventSyntaxRegex.IsMatch(eventText); }
/// <returns>True if the adornment was updated and should be kept. False to have the adornment removed from the view.</returns> protected abstract bool UpdateAdornment(TAdornment adornment, TData data, SnapshotSpan snapshot, SnapshotSpan containSpan);
public void OnClassificationChanged(SnapshotSpan span) { ClassificationChanged(this, new ClassificationChangedEventArgs(span)); }
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (spans.Count == 0) { // there is no content in the buffer yield break; } bool labelGraph_Enabled = this._labelGraph.Enabled; bool asmSimulator_Enabled = this._asmSimulator.Enabled; if (!labelGraph_Enabled && !asmSimulator_Enabled) { // nothing to decorate yield break; } DateTime time1 = DateTime.Now; //TODO move the followign boolean to constructor bool Decorate_Undefined_Labels = labelGraph_Enabled && Settings.Default.IntelliSense_Decorate_Undefined_Labels; bool Decorate_Clashing_Labels = labelGraph_Enabled && Settings.Default.IntelliSense_Decorate_Clashing_Labels; bool Decorate_Undefined_Includes = labelGraph_Enabled && Settings.Default.IntelliSense_Show_Undefined_Includes; bool Decorate_Registers_Known_Register_Values = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Registers; bool Decorate_Syntax_Errors = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Syntax_Errors; bool Decorate_Unimplemented = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Unimplemented; bool Decorate_Usage_Of_Undefined = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Usage_Of_Undefined; bool Decorate_Redundant_Instructions = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Redundant_Instructions; bool Decorate_Unreachable_Instructions = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Unreachable_Instructions; bool Show_Syntax_Error_Error_List = asmSimulator_Enabled && Settings.Default.AsmSim_Show_Syntax_Errors; bool Show_Usage_Of_Undefined = asmSimulator_Enabled && Settings.Default.AsmSim_Show_Usage_Of_Undefined; AssemblerEnum usedAssember = AsmDudeToolsStatic.Used_Assembler; foreach (IMappingTagSpan <AsmTokenTag> asmTokenTag in this._aggregator.GetTags(spans)) { SnapshotSpan tagSpan = asmTokenTag.Span.GetSpans(this._sourceBuffer)[0]; //AsmDudeToolsStatic.Output_INFO(string.Format("SquigglesTagger:GetTags: found keyword \"{0}\"", tagSpan.GetText())); int lineNumber = AsmDudeToolsStatic.Get_LineNumber(tagSpan); switch (asmTokenTag.Tag.Type) { case AsmTokenType.Label: { if (Decorate_Undefined_Labels) { string label = tagSpan.GetText(); string full_Qualified_Label = AsmDudeToolsStatic.Make_Full_Qualified_Label(asmTokenTag.Tag.Misc, label, usedAssember); if (this._labelGraph.Has_Label(full_Qualified_Label)) { // Nothing to report } else { //AsmDudeToolsStatic.Output_INFO(string.Format("SquigglesTagger:GetTags: found label \"{0}\"; full-label \"{1}\"", label, full_Qualified_Label)); if (usedAssember == AssemblerEnum.MASM) { if (this._labelGraph.Has_Label(label)) { // TODO: is this always a valid label? Nothing to report } else { var toolTipContent = this.Undefined_Label_Tool_Tip_Content(); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent))); } } else { var toolTipContent = this.Undefined_Label_Tool_Tip_Content(); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent))); } } } break; } case AsmTokenType.LabelDef: { if (Decorate_Clashing_Labels) { string label = tagSpan.GetText(); string full_Qualified_Label = AsmDudeToolsStatic.Make_Full_Qualified_Label(asmTokenTag.Tag.Misc, label, usedAssember); if (this._labelGraph.Has_Label_Clash(full_Qualified_Label)) { var toolTipContent = this.Label_Clash_Tool_Tip_Content(full_Qualified_Label); //PredefinedErrorTypeNames.Warning is green //PredefinedErrorTypeNames.SyntaxError is red //PredefinedErrorTypeNames.CompilerError is blue //PredefinedErrorTypeNames.Suggestion is NOTHING //PredefinedErrorTypeNames.OtherError is purple yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent))); } } break; } case AsmTokenType.Register: { if (Decorate_Registers_Known_Register_Values) { Rn regName = RegisterTools.ParseRn(tagSpan.GetText()); //AsmDudeToolsStatic.Output_INFO("SquigglesTagger:GetTags: found register " + regName + " at line " + lineNumber); bool preCompute = false; var(HasValue1, Bussy1) = this._asmSimulator.Has_Register_Value(regName, lineNumber, true, preCompute); if (!Bussy1) { var(HasValue2, Bussy2) = this._asmSimulator.Has_Register_Value(regName, lineNumber, false, preCompute); if (!Bussy2) { if ((HasValue1 || HasValue2)) { // only show squiggles to indicate that information is available //AsmDudeToolsStatic.Output_INFO("SquigglesTagger:GetTags: adding squiggles for register " + regName + " at line " + lineNumber); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.Warning))); } } } } break; } case AsmTokenType.Mnemonic: { if (Decorate_Syntax_Errors || Decorate_Unimplemented) { if (this._asmSimulator.Is_Implemented(lineNumber)) { if (Decorate_Syntax_Errors && this._asmSimulator.Has_Syntax_Error(lineNumber)) { string message = AsmSourceTools.Linewrap("Syntax Error: " + this._asmSimulator.Get_Syntax_Error(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, message))); } } else if (Decorate_Unimplemented) { string message = AsmSourceTools.Linewrap("Info: Instruction " + tagSpan.GetText() + " is not (yet) supported by the simulator.", AsmDudePackage.maxNumberOfCharsInToolTips); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.CompilerError, message))); } } if (Decorate_Usage_Of_Undefined) { if (this._asmSimulator.Has_Usage_Undefined_Warning(lineNumber)) { string message = AsmSourceTools.Linewrap("Semantic Warning: " + this._asmSimulator.Get_Usage_Undefined_Warning(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.OtherError, message))); } } if (Decorate_Redundant_Instructions) { if (this._asmSimulator.Has_Redundant_Instruction_Warning(lineNumber)) { string message = AsmSourceTools.Linewrap("Semantic Warning: " + this._asmSimulator.Get_Redundant_Instruction_Warning(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.OtherError, message))); } } if (Decorate_Unreachable_Instructions) { if (this._asmSimulator.Has_Unreachable_Instruction_Warning(lineNumber)) { string message = AsmSourceTools.Linewrap("Semantic Warning: " + this._asmSimulator.Get_Unreachable_Instruction_Warning(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips); yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.OtherError, message))); } } break; } case AsmTokenType.Constant: { if (Decorate_Undefined_Includes) { foreach (var tup in this._labelGraph.Undefined_Includes) { if (tup.LineNumber == lineNumber) //TODO this is inefficient! { var toolTipContent = "Could not resolve include \"" + tagSpan.GetText() + "\""; yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent))); break; // leave the foreach loop } } } break; } default: break; } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "SquiggleTagger"); }
/// <summary> /// Initializes a new instance of <see cref="RegionsChangedEventArgs"/> with the specified <see cref="SnapshotSpan" />. /// </summary> /// <param name="affectedSpan">The <see cref="SnapshotSpan"/> over which collapsible regions have changed.</param> public RegionsChangedEventArgs(SnapshotSpan affectedSpan) { this.AffectedSpan = affectedSpan; }
public static NormalizedSnapshotSpanCollection GetSpanInView(this ITextView textView, SnapshotSpan span) { return(textView.BufferGraph.MapUpToSnapshot(span, SpanTrackingMode.EdgeInclusive, textView.TextSnapshot)); }
public static bool IsReadOnlyOnSurfaceBuffer(this ITextView textView, SnapshotSpan span) { var spansInView = textView.BufferGraph.MapUpToBuffer(span, SpanTrackingMode.EdgeInclusive, textView.TextBuffer); return(spansInView.Any(spanInView => textView.TextBuffer.IsReadOnly(spanInView.Span))); }
/// <summary> /// Get misspelled words in the given set of spans /// </summary> /// <param name="spans">The spans to check</param> /// <returns>An enumerable list of misspelling tags</returns> private IEnumerable <MisspellingTag> GetMisspellingsInSpans(NormalizedSnapshotSpanCollection spans) { List <Match> xmlTags = null; SnapshotSpan errorSpan, deleteWordSpan; Microsoft.VisualStudio.Text.Span lastWord; string text, textToParse; var ignoredWords = wordsIgnoredOnce; foreach (var span in spans) { text = span.GetText(); // Note the location of all XML elements if needed if (configuration.IgnoreXmlElementsInText) { xmlTags = reXml.Matches(text).OfType <Match>().ToList(); } lastWord = new Microsoft.VisualStudio.Text.Span(); foreach (var word in GetWordsInText(text)) { textToParse = text.Substring(word.Start, word.Length); // Spell check the word if it looks like one and is not ignored if (IsProbablyARealWord(textToParse) && (xmlTags == null || xmlTags.Count == 0 || !xmlTags.Any(match => word.Start >= match.Index && word.Start <= match.Index + match.Length - 1))) { // Check for a doubled word. This isn't perfect as it won't detected doubled words // across a line break. if (lastWord.Length != 0 && text.Substring(lastWord.Start, lastWord.Length).Equals( textToParse, StringComparison.OrdinalIgnoreCase) && String.IsNullOrWhiteSpace( text.Substring(lastWord.Start + lastWord.Length, word.Start - lastWord.Start - lastWord.Length))) { errorSpan = new SnapshotSpan(span.Start + word.Start, word.Length); // If the doubled word is not being ignored at the current location, return it if (!ignoredWords.Any(w => w.StartPoint == errorSpan.Start && w.Word.Equals(textToParse, StringComparison.OrdinalIgnoreCase))) { // Delete the whitespace ahead of it too deleteWordSpan = new SnapshotSpan(span.Start + lastWord.Start + lastWord.Length, word.Length + word.Start - lastWord.Start - lastWord.Length); yield return(new MisspellingTag(errorSpan, deleteWordSpan)); lastWord = word; continue; } } lastWord = word; if (!_dictionary.ShouldIgnoreWord(textToParse) && !_dictionary.IsSpelledCorrectly(textToParse)) { // Sometimes it flags a word as misspelled if it ends with "'s". Try checking the // word without the "'s". If ignored or correct without it, don't flag it. This // appears to be caused by the definitions in the dictionary rather than Hunspell. if (textToParse.EndsWith("'s", StringComparison.OrdinalIgnoreCase)) { textToParse = textToParse.Substring(0, textToParse.Length - 2); if (_dictionary.ShouldIgnoreWord(textToParse) || _dictionary.IsSpelledCorrectly(textToParse)) { continue; } textToParse += "'s"; } // Some dictionaries include a trailing period on certain words such as "etc." which // we don't include. If the word is followed by a period, try it with the period to // see if we get a match. If so, consider it valid. if (word.Start + word.Length < text.Length && text[word.Start + word.Length] == '.') { if (_dictionary.ShouldIgnoreWord(textToParse + ".") || _dictionary.IsSpelledCorrectly(textToParse + ".")) { continue; } } errorSpan = new SnapshotSpan(span.Start + word.Start, word.Length); // If the word is not being ignored at the current location, return it and its // suggested corrections. if (!ignoredWords.Any(w => w.StartPoint == errorSpan.Start && w.Word.Equals(textToParse, StringComparison.OrdinalIgnoreCase))) { yield return(new MisspellingTag(errorSpan, _dictionary.SuggestCorrections(textToParse))); } } } } } }
/// <summary> /// Adds the scarlet box behind the 'a' characters within the given line /// </summary> /// <param name="line">Line to add the adornments</param> private void CreateVisuals(SnapshotSpan leftItem, SnapshotSpan rightItem) { if (VSPackage.Options != null) { this.layer.RemoveAllAdornments(); var swapColor = (Color)ColorConverter.ConvertFromString(VSPackage.Options.ArrowColor); var swapPenBrush = new SolidColorBrush(swapColor); swapPenBrush.Freeze(); var swapPen = new Pen(swapPenBrush, 2); swapPen.Freeze(); var textViewLines = this.view.TextViewLines; renderAdorner(leftItem, false); renderAdorner(rightItem, true); void renderAdorner(SnapshotSpan snapshotSpan, bool isRight) { var geometry = textViewLines.GetMarkerGeometry(snapshotSpan); if (geometry != null) { var swapRect = new Rect(geometry.Bounds.Location, geometry.Bounds.Size); swapRect.Inflate(4, 4); var swapLine = new GeometryGroup(); switch (VSPackage.Options.AdornmentType) { case 1: swapLine = MakeSwapArrow(swapRect); break; case 2: swapLine = MakeSwapBracket(swapRect); break; case 3: swapLine = MakeSwapBadge(swapRect); break; } var drawing = new GeometryDrawing(new SolidColorBrush(swapColor), swapPen, swapLine); drawing.Freeze(); var drawingImage = new DrawingImage(drawing); drawingImage.Freeze(); var swapImage = new Image { Source = drawingImage, }; if (isRight) { Canvas.SetLeft(swapImage, swapRect.Right - drawing.Bounds.Width); Canvas.SetTop(swapImage, swapRect.Top); swapImage.RenderTransformOrigin = new Point(0.5, 0.5); var flipTrans = new ScaleTransform(-1, 1); swapImage.RenderTransform = flipTrans; } else { Canvas.SetLeft(swapImage, swapRect.Left); Canvas.SetTop(swapImage, swapRect.Top); } this.layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, snapshotSpan, null, swapImage, null); } } } }
public InlineRenameSession( IThreadingContext threadingContext, InlineRenameService renameService, Workspace workspace, SnapshotSpan triggerSpan, IInlineRenameInfo renameInfo, SymbolRenameOptions options, bool previewChanges, IUIThreadOperationExecutor uiThreadOperationExecutor, ITextBufferAssociatedViewService textBufferAssociatedViewService, ITextBufferFactoryService textBufferFactoryService, IFeatureServiceFactory featureServiceFactory, IEnumerable <IRefactorNotifyService> refactorNotifyServices, IAsynchronousOperationListener asyncListener) { // This should always be touching a symbol since we verified that upon invocation _threadingContext = threadingContext; _renameInfo = renameInfo; _triggerSpan = triggerSpan; _triggerDocument = triggerSpan.Snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (_triggerDocument == null) { throw new InvalidOperationException(EditorFeaturesResources.The_triggerSpan_is_not_included_in_the_given_workspace); } _inlineRenameSessionDurationLogBlock = Logger.LogBlock(FunctionId.Rename_InlineSession, CancellationToken.None); _workspace = workspace; _workspace.WorkspaceChanged += OnWorkspaceChanged; _textBufferFactoryService = textBufferFactoryService; _textBufferAssociatedViewService = textBufferAssociatedViewService; _textBufferAssociatedViewService.SubjectBuffersConnected += OnSubjectBuffersConnected; // Disable completion when an inline rename session starts _featureService = featureServiceFactory.GlobalFeatureService; _completionDisabledToken = _featureService.Disable(PredefinedEditorFeatureNames.Completion, this); RenameService = renameService; _uiThreadOperationExecutor = uiThreadOperationExecutor; _refactorNotifyServices = refactorNotifyServices; _asyncListener = asyncListener; _triggerView = textBufferAssociatedViewService.GetAssociatedTextViews(triggerSpan.Snapshot.TextBuffer).FirstOrDefault(v => v.HasAggregateFocus) ?? textBufferAssociatedViewService.GetAssociatedTextViews(triggerSpan.Snapshot.TextBuffer).First(); _options = options; _previewChanges = previewChanges; _initialRenameText = triggerSpan.GetText(); this.ReplacementText = _initialRenameText; _baseSolution = _triggerDocument.Project.Solution; this.UndoManager = workspace.Services.GetService <IInlineRenameUndoManager>(); if (_renameInfo is IInlineRenameInfoWithFileRename renameInfoWithFileRename) { FileRenameInfo = renameInfoWithFileRename.GetFileRenameInfo(); } else { FileRenameInfo = InlineRenameFileRenameInfo.NotAllowed; } InitializeOpenBuffers(triggerSpan); }
private String GetDocText(SnapshotSpan span) { return(span.Snapshot.GetText()); }
public IEnumerable <SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken) { lock (_currentLock) { if (_currentSpan == range) { return(_current); } } return(null); }
public async Task <bool> HasSuggestedActionsAsync(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken) { var pos = _view.Caret.Position.BufferPosition; if (pos.Position < pos.GetContainingLine().End.Position) { pos += 1; } var targetPoint = _view.BufferGraph.MapDownToFirstMatch(pos, PointTrackingMode.Positive, EditorExtensions.IsPythonContent, PositionAffinity.Successor); if (targetPoint == null) { return(false); } var textBuffer = targetPoint.Value.Snapshot.TextBuffer; var lineStart = targetPoint.Value.GetContainingLine().Start; var span = targetPoint.Value.Snapshot.CreateTrackingSpan( lineStart, targetPoint.Value.Position - lineStart.Position, SpanTrackingMode.EdgePositive, TrackingFidelityMode.Forward ); var imports = await _uiThread.InvokeTask(() => VsProjectAnalyzer.GetMissingImportsAsync(_provider, _view, textBuffer.CurrentSnapshot, span)); if (imports == MissingImportAnalysis.Empty) { return(false); } var suggestions = new List <SuggestedActionSet>(); var availableImports = await imports.GetAvailableImportsAsync(cancellationToken); suggestions.Add(new SuggestedActionSet( availableImports.Select(s => new PythonSuggestedImportAction(this, textBuffer, s)) .OrderBy(k => k) .Distinct() )); cancellationToken.ThrowIfCancellationRequested(); if (!suggestions.SelectMany(s => s.Actions).Any()) { return(false); } lock (_currentLock) { cancellationToken.ThrowIfCancellationRequested(); _current = suggestions; _currentSpan = range; } return(true); }
public static IList <ClassificationSpan> GetClassificationSpans(this IGherkinFileScope gherkinFileScope, SnapshotSpan snapshotSpan) { if (gherkinFileScope == null) { return(new ClassificationSpan[0]); } var result = new List <ClassificationSpan>(); foreach (var gherkinFileBlock in gherkinFileScope.GetAllBlocks()) { result.AddRange(gherkinFileBlock.ClassificationSpans); //TODO: optimize } return(result); }
public IEnumerable <ITagSpan <AsmTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans) { DateTime time1 = DateTime.Now; if (spans.Count == 0) { //there is no content in the buffer yield break; } foreach (SnapshotSpan curSpan in spans) { ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine(); string line = containingLine.GetText().ToUpper(); var pos = new List <(int BeginPos, int Length, bool IsLabel)>(AsmSourceTools.SplitIntoKeywordPos(line)); int offset = containingLine.Start.Position; int nKeywords = pos.Count; for (int k = 0; k < nKeywords; k++) { string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line); // keyword starts with a remark char if (AsmSourceTools.IsRemarkChar(asmToken[0])) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._remark)); continue; } // keyword k is a label definition if (pos[k].IsLabel) { SnapshotSpan labelDefSpan = NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan); //AsmDudeToolsStatic.Output_INFO("MasmTokenTagger:GetTags: found label " + asmToken +" at line "+containingLine.LineNumber); if (asmToken.Equals("@@")) { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. } else { var v = Make_AsmTokenTag_LabelDef(containingLine.LineNumber); yield return(new TagSpan <AsmTokenTag>(labelDefSpan, v)); } continue; } AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken); switch (keywordType) { case AsmTokenType.Jump: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump)); k++; // goto the next word if (k == nKeywords) { break; } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); switch (asmToken2) { case "$": case "@B": case "@F": { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. break; } case "WORD": case "DWORD": case "QWORD": case "SHORT": case "NEAR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc)); k++; if (k == nKeywords) { break; } string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line); switch (asmToken3) { case "$": case "@B": case "@F": { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. break; } case "PTR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc)); break; } default: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber))); break; } } break; } default: { if (RegisterTools.IsRegister(asmToken2)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register)); } else { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber))); } break; } } break; } case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical { //if (AsmTools.AsmSourceTools.Evaluate_Constant(asmToken, true).Valid) if (AsmTools.AsmSourceTools.Parse_Constant(asmToken, true).Valid) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); } else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\"")) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); } else { bool isUnknown = true; // do one word lookahead; see whether we can understand the current unknown word if ((k + 1) < nKeywords) { k++; string nextKeyword = NasmIntelTokenTagger.Keyword(pos[k], line); switch (nextKeyword) { case "PROC": case "EQU": case "LABEL": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef)); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); isUnknown = false; break; } case "PROTO": { // a proto is considered a label definition but it should not clash with other label definitions yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef_PROTO)); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); isUnknown = false; break; } default: { k--; break; } } } // do one word look back; see whether we can understand the current unknown word if (k > 0) { string previousKeyword = NasmIntelTokenTagger.Keyword(pos[k - 1], line); switch (previousKeyword) { case "ALIAS": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef)); isUnknown = false; break; } case "INCLUDE": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); isUnknown = false; break; } default: { break; } } } if (isUnknown) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN)); } } break; } case AsmTokenType.Directive: { AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken); if (assember.HasFlag(AssemblerEnum.MASM)) // this MASM token-tagger only tags MASM directives { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); switch (asmToken) { case "INVOKE": { k++; // goto the next word if (k == nKeywords) { break; } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber))); break; } case "EXTRN": case "EXTERN": { k++; // goto the next word if (k == nKeywords) { break; } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef_PROTO)); break; } } } } break; default: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType))); break; } } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "MasmTokenTagger"); }
internal bool TryGetSpanOnHigherBuffer(SnapshotSpan snapshotSpan, ITextBuffer targetBuffer, out SnapshotSpan span) { var spanCollection = TextView.BufferGraph.MapUpToBuffer(snapshotSpan, SpanTrackingMode.EdgeExclusive, targetBuffer); // Bail if a snippet span does not map up to exactly one span. if (spanCollection.Count == 1) { span = spanCollection.Single(); return(true); } span = default(SnapshotSpan); return(false); }
private IEnumerable <ITagSpan <TTag> > GetTagsForLargeNumberOfSpans(NormalizedSnapshotSpanCollection requestedSpans) { // we are asked with bunch of spans. rather than asking same question again and again, ask once with big span // which will return superset of what we want. and then filter them out in O(m+n) cost. // m == number of requested spans, n = number of returned spans var mergedSpan = new SnapshotSpan(requestedSpans[0].Start, requestedSpans[requestedSpans.Count - 1].End); var result = GetIntersectingSpans(mergedSpan); int requestIndex = 0; var enumerator = result.GetEnumerator(); try { if (!enumerator.MoveNext()) { return(SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >()); } var hashSet = new HashSet <ITagSpan <TTag> >(); while (true) { var currentTag = enumerator.Current; var currentRequestSpan = requestedSpans[requestIndex]; var currentTagSpan = currentTag.Span; if (currentRequestSpan.Start > currentTagSpan.End) { if (!enumerator.MoveNext()) { break; } } else if (currentTagSpan.Start > currentRequestSpan.End) { requestIndex++; if (requestIndex >= requestedSpans.Count) { break; } } else { if (currentTagSpan.Length > 0) { hashSet.Add(currentTag); } if (!enumerator.MoveNext()) { break; } } } return(hashSet); } finally { enumerator.Dispose(); } }
private static bool TryMapToSingleSnapshotSpan(IMappingSpan mappingSpan, ITextSnapshot viewSnapshot, out SnapshotSpan span) { // IMappingSpan.GetSpans is a surprisingly expensive function that allocates multiple // lists and collection if the view buffer is same as anchor we could just map the // anchor to the viewSnapshot however, since the _anchor is not available, we have to // map start and end TODO: verify that affinity is correct. If it does not matter we // should use the cheapest. if (viewSnapshot != null && mappingSpan.AnchorBuffer == viewSnapshot.TextBuffer) { var mappedStart = mappingSpan.Start.GetPoint(viewSnapshot, PositionAffinity.Predecessor).Value; var mappedEnd = mappingSpan.End.GetPoint(viewSnapshot, PositionAffinity.Successor).Value; span = new SnapshotSpan(mappedStart, mappedEnd); return(true); } // TODO: actually adornments do not make much sense on "cropped" spans either - Consider line separator on "nd Su" // is it possible to cheaply detect cropping? var spans = mappingSpan.GetSpans(viewSnapshot); if (spans.Count != 1) { span = default; return(false); // span is unmapped or disjoint. } span = spans[0]; return(true); }
protected virtual SnapshotSpan AdjustSnapshotSpan(SnapshotSpan span, int minimumLength) => AdjustSnapshotSpan(span, minimumLength, int.MaxValue);
private void AddClassifiedSpansForPreviousTree <TClassificationService>( IClassificationDelegationService <TClassificationService> delegationService, TClassificationService classificationService, SnapshotSpan span, ITextSnapshot lastSnapshot, Document lastDocument, List <ClassifiedSpan> classifiedSpans) { // Slightly more complicated case. They're asking for the classifications for a // different snapshot than what we have a parse tree for. So we first translate the span // that they're asking for so that is maps onto the tree that we have spans for. We then // get the classifications from that tree. We then take the results and translate them // back to the snapshot they want. Finally, as some of the classifications may have // changed, we check for some common cases and touch them up manually so that things // look right for the user. // Note the handling of SpanTrackingModes here: We do EdgeExclusive while mapping back , // and EdgeInclusive mapping forward. What I've convinced myself is that EdgeExclusive // is best when mapping back over a deletion, so that we don't end up classifying all of // the deleted code. In most addition/modification cases, there will be overlap with // existing spans, and so we'll end up classifying well. In the worst case, there is a // large addition that doesn't exist when we map back, and so we don't have any // classifications for it. That's probably okay, because: // 1. If it's that large, it's likely that in reality there are multiple classification // spans within it. // 2.We'll eventually call ClassificationsChanged and re-classify that region anyway. // When mapping back forward, we use EdgeInclusive so that in the common typing cases we // don't end up with half a token colored differently than the other half. // See bugs like http://vstfdevdiv:8080/web/wi.aspx?id=6176 for an example of what can // happen when this goes wrong. // 1) translate the requested span onto the right span for the snapshot that corresponds // to the syntax tree. var translatedSpan = span.TranslateTo(lastSnapshot, SpanTrackingMode.EdgeExclusive); if (translatedSpan.IsEmpty) { // well, there is no information we can get from previous tree, use lexer to // classify given span. soon we will re-classify the region. AddClassifiedSpansForTokens(delegationService, classificationService, span, classifiedSpans); return; } var tempList = ClassificationUtilities.GetOrCreateClassifiedSpanList(); AddClassifiedSpansForCurrentTree( delegationService, classificationService, translatedSpan, lastDocument, tempList); var currentSnapshot = span.Snapshot; var currentText = currentSnapshot.AsText(); foreach (var lastClassifiedSpan in tempList) { // 2) Translate those classifications forward so that they correspond to the true // requested snapshot. var lastSnapshotSpan = lastClassifiedSpan.TextSpan.ToSnapshotSpan(lastSnapshot); var currentSnapshotSpan = lastSnapshotSpan.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeInclusive); var currentClassifiedSpan = new ClassifiedSpan(lastClassifiedSpan.ClassificationType, currentSnapshotSpan.Span.ToTextSpan()); // 3) The classifications may be incorrect due to changes in the text. For example, // if "clss" becomes "class", then we want to changes the classification from // 'identifier' to 'keyword'. currentClassifiedSpan = delegationService.AdjustStaleClassification( classificationService, currentText, currentClassifiedSpan); classifiedSpans.Add(currentClassifiedSpan); } ClassificationUtilities.ReturnClassifiedSpanList(tempList); }
private static TagSpan <IOutliningRegionTag> CreateTag(SnapshotSpan span, string text, string tooltip = null) { var tag = new OutliningRegionTag(false, false, text, tooltip); return(new TagSpan <IOutliningRegionTag>(span, tag)); }
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { var snapshot = span.Snapshot; var workspace = snapshot.TextBuffer.GetWorkspace(); if (workspace == null) { return(Array.Empty <ClassificationSpan>()); } var result = new List <ClassificationSpan>(16); var semanticModel = ThreadHelper.JoinableTaskFactory.Run(() => workspace.GetDocument(span).GetSemanticModelAsync()); var textSpan = new TextSpan(span.Start.Position, span.Length); var unitCompilation = semanticModel.SyntaxTree.GetCompilationUnitRoot(); var classifiedSpans = Classifier.GetClassifiedSpans(semanticModel, textSpan, workspace); var lastTriviaSpan = default(TextSpan); GetAttributeNotationSpan(snapshot, result, textSpan, unitCompilation); foreach (var item in classifiedSpans) { var ct = item.ClassificationType; switch (ct) { case "keyword": { var node = unitCompilation.FindNode(item.TextSpan, true, true); if (node is MemberDeclarationSyntax) { var token = unitCompilation.FindToken(item.TextSpan.Start); if (token != null) { switch (token.Kind()) { case SyntaxKind.SealedKeyword: case SyntaxKind.OverrideKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.VirtualKeyword: case SyntaxKind.NewKeyword: result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _Classifications.AbstractionKeyword)); continue; } } continue; } const SyntaxKind ThrowExpression = (SyntaxKind)9052; switch (node.Kind()) { case SyntaxKind.BreakStatement: if (node.Parent is SwitchSectionSyntax == false) { goto case SyntaxKind.ReturnStatement; } continue; // highlights: return, yield return, yield break, throw and continue case SyntaxKind.ReturnKeyword: case SyntaxKind.GotoCaseStatement: case SyntaxKind.GotoDefaultStatement: case SyntaxKind.GotoStatement: case SyntaxKind.ContinueStatement: case SyntaxKind.ReturnStatement: case SyntaxKind.YieldReturnStatement: case SyntaxKind.YieldBreakStatement: case SyntaxKind.ThrowStatement: case ThrowExpression: result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _GeneralClassifications.ControlFlowKeyword)); continue; case SyntaxKind.IfStatement: case SyntaxKind.ElseClause: case SyntaxKind.SwitchStatement: case SyntaxKind.CaseSwitchLabel: case SyntaxKind.DefaultSwitchLabel: result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _GeneralClassifications.BranchingKeyword)); continue; case SyntaxKind.ForStatement: case SyntaxKind.ForEachStatement: case SyntaxKind.WhileStatement: case SyntaxKind.DoStatement: case SyntaxKind.SelectClause: result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _GeneralClassifications.LoopKeyword)); continue; case SyntaxKind.UsingStatement: case SyntaxKind.FixedStatement: case SyntaxKind.LockStatement: case SyntaxKind.UnsafeStatement: case SyntaxKind.TryStatement: case SyntaxKind.CatchClause: case SyntaxKind.CatchFilterClause: case SyntaxKind.FinallyClause: result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _Classifications.ResourceKeyword)); continue; } } continue; case Constants.CodePunctuation: if (item.TextSpan.Length == 1) { ClassifyPunctuation(item.TextSpan, snapshot, result, semanticModel, unitCompilation); } continue; default: if (ct == Constants.XmlDocDelimiter) { if (lastTriviaSpan.Contains(item.TextSpan)) { continue; } var node = unitCompilation.FindTrivia(item.TextSpan.Start); if (node != null) { switch (node.Kind()) { case SyntaxKind.SingleLineDocumentationCommentTrivia: case SyntaxKind.MultiLineDocumentationCommentTrivia: case SyntaxKind.DocumentationCommentExteriorTrivia: lastTriviaSpan = node.FullSpan; result.Add(CreateClassificationSpan(snapshot, lastTriviaSpan, _Classifications.XmlDoc)); continue; } } } else if (ct == Constants.CodeIdentifier || ct.EndsWith("name", StringComparison.Ordinal)) { var itemSpan = item.TextSpan; var node = unitCompilation.FindNode(itemSpan, true); foreach (var type in GetClassificationType(node, semanticModel)) { result.Add(CreateClassificationSpan(snapshot, itemSpan, type)); } } break; } } return(result); }
public IEnumerable <TrackingTokenInfo> GetTokens(SnapshotSpan span) { return(GetTrackingTokens(span)); }
/// <summary> /// Convert the SnapshotSpan into an EditSpan /// </summary> public static EditSpan ToEditSpan(this SnapshotSpan span) { return(EditSpan.NewSingle(span)); }
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan) { applicableToSpan = null; if (session == null || quickInfoContent == null) { return; } if (session.TextView.TextBuffer == this.TextBuffer) { ITextSnapshot currentSnapshot = this.TextBuffer.CurrentSnapshot; SnapshotPoint?triggerPoint = session.GetTriggerPoint(currentSnapshot); if (!triggerPoint.HasValue) { return; } #region experimental /* use the experimental model to locate and process the expression */ Stopwatch stopwatch = Stopwatch.StartNew(); // lex the entire document var input = new SnapshotCharStream(currentSnapshot, new Span(0, currentSnapshot.Length)); var lexer = new GoLexer(input); var tokenSource = new GoSemicolonInsertionTokenSource(lexer); var tokens = new CommonTokenStream(tokenSource); tokens.Fill(); // locate the last token before the trigger point while (true) { IToken nextToken = tokens.LT(1); if (nextToken.Type == CharStreamConstants.EndOfFile) { break; } if (nextToken.StartIndex > triggerPoint.Value.Position) { break; } tokens.Consume(); } switch (tokens.LA(-1)) { case GoLexer.IDENTIFIER: //case GoLexer.KW_THIS: //case GoLexer.KW_UNIV: //case GoLexer.KW_IDEN: //case GoLexer.KW_INT2: //case GoLexer.KW_SEQINT: break; default: return; } Network network = NetworkBuilder <GoSimplifiedAtnBuilder> .GetOrBuildNetwork(); RuleBinding memberSelectRule = network.GetRule(GoSimplifiedAtnBuilder.RuleNames.PrimaryExpr); #if false HashSet <Transition> memberSelectTransitions = new HashSet <Transition>(); GetReachableTransitions(memberSelectRule, memberSelectTransitions); #endif NetworkInterpreter interpreter = new NetworkInterpreter(network, tokens); interpreter.BoundaryRules.Add(memberSelectRule); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.Label)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.TypeSwitchGuard)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.FieldName)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.Receiver)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.FunctionDecl)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.BaseTypeName)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.TypeSpec)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.IdentifierList)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.MethodName)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.ParameterDecl)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.FieldIdentifierList)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.PackageName)); interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.TypeName)); interpreter.ExcludedStartRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.Block)); while (interpreter.TryStepBackward()) { if (interpreter.Contexts.Count == 0) { break; } /* we want all traces to start outside the binOpExpr18 rule, which means all * traces with a transition reachable from binOpExpr18 should contain a push * transition with binOpExpr18's start state as its target. */ if (interpreter.Contexts.All(context => context.BoundedStart)) { break; } } interpreter.CombineBoundedStartContexts(); IOutputWindowPane pane = Provider.OutputWindowService.TryGetPane(PredefinedOutputWindowPanes.TvlIntellisense); if (pane != null) { pane.WriteLine(string.Format("Located {0} QuickInfo expression(s) in {1}ms.", interpreter.Contexts.Count, stopwatch.ElapsedMilliseconds)); } HashSet <string> finalResult = new HashSet <string>(); SnapshotSpan? contextSpan = null; foreach (var context in interpreter.Contexts) { Span?span = null; //List<string> results = AnalyzeInterpreterTrace(context, memberSelectRule, out span); foreach (var transition in context.Transitions) { if (!transition.Transition.IsMatch) { continue; } IToken token = transition.Token; Span tokenSpan = new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1); if (span == null) { span = tokenSpan; } else { span = Span.FromBounds(Math.Min(span.Value.Start, tokenSpan.Start), Math.Max(span.Value.End, tokenSpan.End)); } } if (span.HasValue && !span.Value.IsEmpty) { contextSpan = new SnapshotSpan(currentSnapshot, span.Value); } //if (results.Count > 0) //{ // finalResult.UnionWith(results); // applicableToSpan = currentSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive); //} } foreach (var result in finalResult) { quickInfoContent.Add(result); } #endregion #if false var selection = session.TextView.Selection.StreamSelectionSpan; if (selection.IsEmpty || !selection.Contains(new VirtualSnapshotPoint(triggerPoint.Value))) { SnapshotSpan?expressionSpan = Provider.IntellisenseCache.GetExpressionSpan(triggerPoint.Value); if (expressionSpan.HasValue) { selection = new VirtualSnapshotSpan(expressionSpan.Value); } } #endif VirtualSnapshotSpan selection = new VirtualSnapshotSpan(); if (contextSpan.HasValue) { selection = new VirtualSnapshotSpan(contextSpan.Value); } if (!selection.IsEmpty && selection.Contains(new VirtualSnapshotPoint(triggerPoint.Value))) { applicableToSpan = selection.Snapshot.CreateTrackingSpan(selection.SnapshotSpan, SpanTrackingMode.EdgeExclusive); quickInfoContent.Add(selection.GetText()); //try //{ // Expression currentExpression = Provider.IntellisenseCache.ParseExpression(selection); // if (currentExpression != null) // { // SnapshotSpan? span = currentExpression.Span; // if (span.HasValue) // applicableToSpan = span.Value.Snapshot.CreateTrackingSpan(span.Value, SpanTrackingMode.EdgeExclusive); // quickInfoContent.Add(currentExpression.ToString()); // } // else // { // quickInfoContent.Add("Could not parse expression."); // } //} //catch (Exception ex) //{ // if (ErrorHandler.IsCriticalException(ex)) // throw; // quickInfoContent.Add(ex.Message); //} } } }
public static SnapshotSpan?MapUpOrDownToBuffer(this IBufferGraph bufferGraph, SnapshotSpan span, ITextBuffer targetBuffer) { var direction = ClassifyBufferMapDirection(span.Snapshot.TextBuffer, targetBuffer); switch (direction) { case BufferMapDirection.Identity: return(span); case BufferMapDirection.Down: { var spans = bufferGraph.MapDownToBuffer(span, SpanTrackingMode.EdgeExclusive, targetBuffer); return(spans.Select(s => (SnapshotSpan?)s).FirstOrDefault()); } case BufferMapDirection.Up: { var spans = bufferGraph.MapUpToBuffer(span, SpanTrackingMode.EdgeExclusive, targetBuffer); return(spans.Select(s => (SnapshotSpan?)s).FirstOrDefault()); } default: return(null); } }
// Produces tags on the snapshot that this tagger is current with. private IEnumerable <TagSpan <IntraTextAdornmentTag> > GetAdornmentTagsOnSnapshot(NormalizedSnapshotSpanCollection spans) { if (spans.Count == 0) { yield break; } ITextSnapshot snapshot = spans[0].Snapshot; if (snapshot != this._snapshot) { yield break; } // Since WPF UI objects have state (like mouse hover or animation) and are relatively expensive to create and lay out, // this code tries to reuse controls as much as possible. // The controls are stored in this.adornmentCache between the calls. // Mark which adornments fall inside the requested spans with Keep=false // so that they can be removed from the cache if they no longer correspond to data tags. HashSet <SnapshotSpan> toRemove = new HashSet <SnapshotSpan>(); foreach (var ar in _adornmentCache) { if (spans.IntersectsWith(new NormalizedSnapshotSpanCollection(ar.Key))) { toRemove.Add(ar.Key); } } foreach (var spanDataPair in GetAdornmentData(spans).Distinct(new Comparer())) { // Look up the corresponding adornment or create one if it's new. TAdornment adornment; SnapshotSpan snapshotSpan = spanDataPair.Item1; PositionAffinity?affinity = spanDataPair.Item2; TData adornmentData = spanDataPair.Item3; SnapshotSpan containSpan = spanDataPair.Item4; if (_adornmentCache.TryGetValue(snapshotSpan, out adornment)) { if (UpdateAdornment(adornment, adornmentData, snapshotSpan, containSpan)) { toRemove.Remove(snapshotSpan); } } else { adornment = CreateAdornment(adornmentData, snapshotSpan, containSpan); if (adornment == null) { continue; } // Get the adornment to measure itself. Its DesiredSize property is used to determine // how much space to leave between text for this adornment. // Note: If the size of the adornment changes, the line will be reformatted to accommodate it. // Note: Some adornments may change size when added to the view's visual tree due to inherited // dependency properties that affect layout. Such options can include SnapsToDevicePixels, // UseLayoutRounding, TextRenderingMode, TextHintingMode, and TextFormattingMode. Making sure // that these properties on the adornment match the view's values before calling Measure here // can help avoid the size change and the resulting unnecessary re-format. adornment.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); _adornmentCache.Add(snapshotSpan, adornment); } yield return(new TagSpan <IntraTextAdornmentTag>(snapshotSpan, new IntraTextAdornmentTag(adornment, null, affinity))); } foreach (var snapshotSpan in toRemove) { _adornmentCache.Remove(snapshotSpan); } }
public static SnapshotSpan?MapUpOrDownToFirstMatch(this IBufferGraph bufferGraph, SnapshotSpan span, Predicate <ITextSnapshot> match) { var spans = bufferGraph.MapDownToFirstMatch(span, SpanTrackingMode.EdgeExclusive, match); if (!spans.Any()) { spans = bufferGraph.MapUpToFirstMatch(span, SpanTrackingMode.EdgeExclusive, match); } return(spans.Select(s => (SnapshotSpan?)s).FirstOrDefault()); }
/// <param name="span">这个装饰将会消失的文本范围.</param> /// <returns>Adornment corresponding to given data. May be null.</returns> protected abstract TAdornment CreateAdornment(TData data, SnapshotSpan span, SnapshotSpan containSpan);
private TagSpan <TextMarkerTag> Mark(IMappingTagSpan <LexTag> tagSpan, SnapshotSpan snapshotSpan) { var tagSpans = tagSpan.Span.GetSpans(snapshotSpan.Snapshot); return(new TagSpan <TextMarkerTag>(tagSpans[0], new TextMarkerTag("blue"))); }
/// <summary> /// Causes intra-text adornments to be updated synchronously. /// </summary> protected void RaiseTagsChanged(SnapshotSpan span) { TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(span)); }