internal void ComputeSourceEdits(FrugalList <TextChange> changes) { ITextEdit xedit = this.group.GetEdit((BaseBuffer)this.sourceBuffer); foreach (TextChange change in changes) { if (change.OldLength > 0) { IList <SnapshotSpan> sourceDeletionSpans = this.currentElisionSnapshot.MapToSourceSnapshots(new Span(change.OldPosition, change.OldLength)); foreach (SnapshotSpan sourceDeletionSpan in sourceDeletionSpans) { xedit.Delete(sourceDeletionSpan); } } if (change.NewLength > 0) { // change includes an insertion ReadOnlyCollection <SnapshotPoint> sourceInsertionPoints = this.currentElisionSnapshot.MapInsertionPointToSourceSnapshots(change.OldPosition, null); if (sourceInsertionPoints.Count == 1) { // the insertion point is unambiguous xedit.Insert(sourceInsertionPoints[0].Position, change.NewText); } else { // the insertion is at the boundary of source spans int[] insertionSizes = new int[sourceInsertionPoints.Count]; if (this.resolver != null) { this.resolver.FillInInsertionSizes(new SnapshotPoint(this.currentElisionSnapshot, change.OldPosition), sourceInsertionPoints, change.NewText, insertionSizes); } // if resolver was not provided, we just use zeros for the insertion sizes, which will push the entire insertion // into the last slot. int pos = 0; for (int i = 0; i < insertionSizes.Length; ++i) { // contend with any old garbage that the client passed back. int size = (i == insertionSizes.Length - 1) ? change.NewLength - pos : Math.Min(insertionSizes[i], change.NewLength - pos); if (size > 0) { xedit.Insert(sourceInsertionPoints[i].Position, TextChange.ChangeNewSubstring(change, pos, size)); pos += size; if (pos == change.NewLength) { break; // inserted text is used up, whether we've visited all of the insertionSizes or not } } } } } } this.editApplicationInProgress = true; }
/// <summary> /// Comment out a span of text using the specified block comment format. If the <paramref name="span"/> is /// empty, the entire line containing the span's start point is commented. /// </summary> /// <param name="span">The span of text to comment.</param> /// <param name="edit">The <see cref="ITextEdit"/> to use for applying changes.</param> /// <param name="format">The block comment format.</param> /// <returns>A <see cref="VirtualSnapshotSpan"/> containing the commented code.</returns> /// <exception cref="ArgumentNullException"> /// <para>If <paramref name="edit"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para>If <paramref name="format"/> is <see langword="null"/>.</para> /// </exception> protected virtual VirtualSnapshotSpan CommentBlock(VirtualSnapshotSpan span, ITextEdit edit, BlockCommentFormat format) { if (edit == null) { throw new ArgumentNullException(nameof(edit)); } if (format == null) { throw new ArgumentNullException(nameof(format)); } //special case no selection if (span.IsEmpty) { VirtualSnapshotPoint start = new VirtualSnapshotPoint(span.Start.Position.GetContainingLine().Start + ScanToNonWhitespaceChar(span.Start.Position.GetContainingLine())); VirtualSnapshotPoint end = span.IsInVirtualSpace ? span.End : new VirtualSnapshotPoint(span.End.Position.GetContainingLine().End); span = new VirtualSnapshotSpan(start, end); } // add start comment edit.Insert(span.Start.Position, format.StartText); // add end comment edit.Insert(span.End.Position, format.EndText); return(span); }
/// <summary> /// Inserts a new comment at each virtual point, materializing the virtual space if necessary /// </summary> static void CommentEmptySpans(ITextEdit edit, IEnumerable <VirtualSnapshotPoint> virtualPoints, IEditorOperations editorOperations) { foreach (var virtualPoint in virtualPoints) { if (virtualPoint.IsInVirtualSpace) { string leadingWhitespace; if (editorOperations != null) { leadingWhitespace = editorOperations.GetWhitespaceForVirtualSpace(virtualPoint); } else { leadingWhitespace = new string (' ', virtualPoint.VirtualSpaces); } if (leadingWhitespace.Length > 0) { edit.Insert(virtualPoint.Position, leadingWhitespace); } } edit.Insert(virtualPoint.Position, OpenComment); edit.Insert(virtualPoint.Position, CloseComment); } }
/// <summary> /// Performs the actual insertions of comment markers around the <see cref="commentSpans"/> /// </summary> static void CommentSpans(ITextEdit edit, NormalizedSnapshotSpanCollection commentSpans) { foreach (var commentSpan in commentSpans) { edit.Insert(commentSpan.Start, OpenComment); edit.Insert(commentSpan.End, CloseComment); } }
/// <summary> /// Rollback all modified text in the document except specified <see cref="IDiffChange"/>. /// </summary> /// <param name="diffChange">Information about a specific difference between two sequences.</param> private void RollbackAllButThisChange(IDiffChange diffChange) { ITextEdit edit = _textView.TextBuffer.CreateEdit(); Span viewSpan; try { string modifiedRegionText = _marginCore.GetModifiedText(diffChange, false); string originalText = _marginCore.GetOriginalText(); edit.Delete(0, edit.Snapshot.Length); edit.Insert(0, originalText); ApplyEdit(edit, "Undo Modified Text"); edit = _textView.TextBuffer.CreateEdit(); ITextSnapshotLine startLine = edit.Snapshot.GetLineFromLineNumber(diffChange.OriginalStart); ITextSnapshotLine endLine = edit.Snapshot.GetLineFromLineNumber(diffChange.OriginalEnd); int start = startLine.Start.Position; int length = endLine.EndIncludingLineBreak.Position - start; switch (diffChange.ChangeType) { case DiffChangeType.Insert: edit.Insert(start, modifiedRegionText); viewSpan = new Span(start, modifiedRegionText.Length); break; case DiffChangeType.Delete: edit.Delete(start, length); viewSpan = new Span(start, 0); break; case DiffChangeType.Change: edit.Replace(start, length, modifiedRegionText); viewSpan = new Span(start, modifiedRegionText.Length); break; default: throw new InvalidEnumArgumentException(); } ApplyEdit(edit, "Restore Modified Region"); } catch (Exception) { edit.Cancel(); throw; } var viewSnapshotSpan = new SnapshotSpan(_textView.TextSnapshot, viewSpan); _textView.ViewScroller.EnsureSpanVisible(viewSnapshotSpan, EnsureSpanVisibleOptions.AlwaysCenter); }
void CommentSpan(IEditorOptions options, SnapshotSpan span, ITextEdit textEdit, List <ITrackingSpan> spansToSelect) { var firstAndLastLine = DetermineFirstAndLastLine(span); // Keine Selection, und in die ganze Zeile ist leer if (span.IsEmpty && firstAndLastLine.Item1.IsEmptyOrWhitespace()) { return; } // Blockselektion von leeren Zeilem if (!span.IsEmpty && string.IsNullOrWhiteSpace(span.GetText())) { return; } if (span.IsEmpty || string.IsNullOrWhiteSpace(span.GetText())) { var firstNonWhitespaceOnLine = firstAndLastLine.Item1.GetFirstNonWhitespacePosition(); var insertPosition = firstNonWhitespaceOnLine ?? firstAndLastLine.Item1.Start; // es gibt keine Selektion => ganze Zeile auskommentieren textEdit.Insert(insertPosition, SyntaxFacts.SingleLineComment); spansToSelect.Add(span.Snapshot.CreateTrackingSpan(Span.FromBounds(firstAndLastLine.Item1.Start, firstAndLastLine.Item1.End), SpanTrackingMode.EdgeInclusive)); } else { // Partielle Selektion innerhalb einer Zeile if (!SpanIncludesAllTextOnIncludedLines(span) && firstAndLastLine.Item1.LineNumber == firstAndLastLine.Item2.LineNumber) { textEdit.Insert(span.Start, SyntaxFacts.BlockCommentStart); textEdit.Insert(span.End, SyntaxFacts.BlockCommentEnd); spansToSelect.Add(span.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive)); } else { // Das Kommentare an der kleinsten Spalte beginnen, die nicht aus einem Leerzeichen besteht // Bsp.: // ...A // ....B // ->->C // Kommentar beginnt bei Spalte 3 var indentToColumn = DetermineSmallestSignificantColumn(options, span, firstAndLastLine); ApplyCommentToNonBlankLines(options, textEdit, firstAndLastLine, indentToColumn); // Den ganzen "Block" an Zeilen selektieren spansToSelect.Add(span.Snapshot.CreateTrackingSpan(Span.FromBounds(firstAndLastLine.Item1.Start.Position, firstAndLastLine.Item2.End.Position), SpanTrackingMode.EdgeInclusive)); } } }
public override void Invoke(CancellationToken cancellationToken) { AttributeNode src = Element.GetAttribute("src") ?? Element.GetAttribute("href") ?? Element.GetAttribute("abp-src") ?? Element.GetAttribute("abp-href"); AttributeNode integrity = Element.GetAttribute("integrity"); AttributeNode crossorigin = Element.GetAttribute("crossorigin"); string url = src.Value; if (url.StartsWith("//")) { url = "http:" + url; } string hash = CalculateHash(url); if (string.IsNullOrEmpty(hash)) { MessageBox.Show("Could not resolve the URL to generate the hash", "Web Essentials", MessageBoxButton.OK, MessageBoxImage.Error); return; } try { ProjectHelpers.DTE.UndoContext.Open(DisplayText); using (ITextEdit edit = TextBuffer.CreateEdit()) { if (integrity != null) { var span = new Span(integrity.ValueRangeUnquoted.Start, integrity.ValueRangeUnquoted.Length); edit.Replace(span, hash); } else { edit.Insert(src.ValueRange.End, " integrity=\"" + hash + "\""); } if (crossorigin == null) { edit.Insert(src.ValueRange.End, " crossorigin=\"anonymous\""); } edit.Apply(); } } finally { ProjectHelpers.DTE.UndoContext.Close(); } }
private void CopyLines(IWpfTextView wpfTextView, bool bDirectionDown) { ITextSnapshot snapshot = wpfTextView.TextSnapshot; int lineNumberFirstSelected = 0; int lineNumberLastSelected = 0; if (wpfTextView.Selection.IsEmpty) { lineNumberLastSelected = lineNumberFirstSelected = snapshot.GetLineNumberFromPosition(wpfTextView.Caret.Position.BufferPosition); } else { ITextSelection textSelection = wpfTextView.Selection; lineNumberFirstSelected = snapshot.GetLineNumberFromPosition(textSelection.Start.Position); lineNumberLastSelected = snapshot.GetLineNumberFromPosition(textSelection.End.Position - 1); } string selectedText = ""; ITextSnapshotLine textSnapshotLine; for (int i = lineNumberFirstSelected; i <= lineNumberLastSelected; ++i) { textSnapshotLine = snapshot.GetLineFromLineNumber(i); selectedText += textSnapshotLine.GetTextIncludingLineBreak(); } int newPosSelected = 0; ITextEdit edit = snapshot.TextBuffer.CreateEdit(); if (bDirectionDown) { textSnapshotLine = snapshot.GetLineFromLineNumber(lineNumberLastSelected); newPosSelected = textSnapshotLine.EndIncludingLineBreak; edit.Insert(newPosSelected, selectedText); } else { textSnapshotLine = snapshot.GetLineFromLineNumber(lineNumberFirstSelected); newPosSelected = textSnapshotLine.Start; edit.Insert(newPosSelected, selectedText); } edit.Apply(); SnapshotPoint newSnapshotPoint = new SnapshotPoint(wpfTextView.TextSnapshot, newPosSelected); SnapshotSpan newSnapshotSpan = new SnapshotSpan(newSnapshotPoint, selectedText.Length); wpfTextView.Selection.Select(newSnapshotSpan, false); wpfTextView.Caret.MoveTo(newSnapshotPoint); }
public DragDropPointerEffects HandleDataDropped(DragDropInfo dragDropInfo) { try { SnapshotPoint position = dragDropInfo.VirtualBufferPosition.Position; string header = string.Format(_template, _ext); ITextSnapshotLine line = _view.TextBuffer.CurrentSnapshot.GetLineFromPosition(position); if (!line.Extent.IsEmpty) { header = Environment.NewLine + header; } using (ITextUndoTransaction transaction = _undoManager.TextBufferUndoHistory.CreateTransaction($"Dragged {_ext}")) using (ITextEdit edit = _view.TextBuffer.CreateEdit()) { edit.Insert(position, header); edit.Apply(); transaction.Complete(); } Telemetry.TrackUserTask("FileDragged"); } catch (Exception ex) { Telemetry.TrackException("DragDrop", ex); } return(DragDropPointerEffects.Copy); }
async void IService.HelloWorld() { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); //воротаемся в UI поток. vproject = ProjectHelpers.GetActiveProject(); string rootfolder = vproject.GetRootFolder(); //корневая папка проекта с csproj открытым в студии string vsixdllpath = System.Reflection.Assembly.GetExecutingAssembly().CodeBase.Replace("file:///", ""); string vsixfolder = Path.GetDirectoryName(vsixdllpath); string filename = "tmp1.cs"; string path2addfile = Path.Combine(vsixfolder, "Templates", filename); var filetoadd = new FileInfo(path2addfile); ProjectItem projectItem = null; string fileprojpath = Path.Combine(rootfolder, filename); var filedest = new FileInfo(Path.Combine(fileprojpath)); if (1 == 1) { if (1 == 1) //добавить файл в проект из VSIX папки { ProjectHelpers.CopyTmpToProjectFile(vproject, filetoadd.FullName, filedest.FullName); } projectItem = vproject.AddFileToProject(filedest); vproject.DTE.ItemOperations.OpenFile(fileprojpath); //открыть редактор с новым файлом if (true) //добавить текст { Microsoft.VisualStudio.Text.Editor.IWpfTextView view = ProjectHelpers.GetCurentTextView(); if (view != null) { try { ITextEdit edit = view.TextBuffer.CreateEdit(); edit.Insert(0, Environment.NewLine); edit.Apply(); } catch (Exception e) { } } } if (true) //добавление абсолютной ссылки в проект { VSProject refproject; refproject = (VSProject)vproject.Object; try { refproject.References.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.7.2\Microsoft.Build.dll"); } catch (Exception ddd) { } } } }
public static void Insert(this IWpfTextView obj, int position, string text) { ITextEdit edit = obj.TextSnapshot.TextBuffer.CreateEdit(); edit.Insert(position, text); edit.Apply(); }
public override void Write(char[] buffer, int index, int count) { ITextEdit edit = this.textBuffer.CreateEdit(); edit.Insert(this.textBuffer.CurrentSnapshot.Length, buffer, index, count); edit.Apply(); }
/// <summary> /// Handler for added text of other editor /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void my_AddedText(object sender, EditedTextEventArgs e) { if (e.File == filename) { lock (CoProNetwork.locker) { while (e.Seq != cb.ExpectedSequence)//if excpected id is the id i got { System.Threading.Monitor.Wait(CoProNetwork.locker); Debug.WriteLine("Recieved seq : " + e.Seq + " Expected seq : " + cb.ExpectedSequence); } trackDict[e.Editor] = m_textView.TextSnapshot.CreateTrackingPoint(e.Location, PointTrackingMode.Positive); uiDisp.Invoke(new Action(() => { ITextEdit edit = m_textView.TextBuffer.CreateEdit(); var curTrackPoint = trackDict[e.Editor]; edit.Insert(curTrackPoint.GetPosition(m_textView.TextSnapshot), e.Command); mySideCalling = false; edit.Apply(); edit.Dispose(); })); System.Threading.Monitor.PulseAll(CoProNetwork.locker); } } }
public override bool Indent() { string textToInsert = _editorOptions.IsConvertTabsToSpacesEnabled() ? new string(' ', _editorOptions.GetTabSize()) : "\t"; if (_startPoint.LineNumber == _endPoint.LineNumber) { return(_startPoint.InsertIndent()); } using (ITextEdit edit = TextBuffer.AdvancedTextBuffer.CreateEdit()) { ITextSnapshot snapshot = TextBuffer.AdvancedTextBuffer.CurrentSnapshot; for (int i = _startPoint.LineNumber; i <= _endPoint.LineNumber; i++) { ITextSnapshotLine line = snapshot.GetLineFromLineNumber(i); if ((line.Length > 0) && (line.Start != _endPoint.CurrentPosition)) { if (!edit.Insert(line.Start, textToInsert)) { return(false); } } } edit.Apply(); if (edit.Canceled) { return(false); } } return(true); }
/// <summary> /// Comment out a span using a particular line comment format. If the <paramref name="span"/> is empty, the /// entire line containing the span's start point is commented. /// </summary> /// <remarks> /// <para>The default algorithm for line comments is designed to meet the following conditions.</para> /// <list type="bullet"> /// <item>Make sure line comments are indented as far as possible, skipping empty lines as necessary.</item> /// <item>Don't comment <em>N</em>+1 lines when only <em>N</em> lines were selected by clicking in the left /// margin.</item> /// </list> /// </remarks> /// <param name="span">The span of text to comment.</param> /// <param name="edit">The <see cref="ITextEdit"/> to apply the changes to.</param> /// <param name="format">The line comment format to use for commenting the code.</param> /// <returns>A <see cref="VirtualSnapshotSpan"/> containing the commented code.</returns> /// <exception cref="ArgumentNullException"> /// <para>If <paramref name="edit"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para>If <paramref name="format"/> is <see langword="null"/>.</para> /// </exception> protected virtual VirtualSnapshotSpan CommentLines(VirtualSnapshotSpan span, ITextEdit edit, LineCommentFormat format) { Contract.Requires <ArgumentNullException>(edit != null, "edit"); Contract.Requires <ArgumentNullException>(format != null, "format"); if (span.End.Position.GetContainingLine().LineNumber > span.Start.Position.GetContainingLine().LineNumber&& span.End.Position.GetContainingLine().Start == span.End.Position) { VirtualSnapshotPoint start = span.Start; VirtualSnapshotPoint end = new VirtualSnapshotPoint(span.Snapshot.GetLineFromLineNumber(span.End.Position.GetContainingLine().LineNumber - 1).Start); if (end < start) { start = end; } span = new VirtualSnapshotSpan(start, end); } int minindex = (from i in Enumerable.Range(span.Start.Position.GetContainingLine().LineNumber, span.End.Position.GetContainingLine().LineNumber - span.Start.Position.GetContainingLine().LineNumber + 1) where span.Snapshot.GetLineFromLineNumber(i).GetText().Trim().Length > 0 select ScanToNonWhitespaceChar(span.Snapshot.GetLineFromLineNumber(i))) .Min(); //comment each line for (int line = span.Start.Position.GetContainingLine().LineNumber; line <= span.End.Position.GetContainingLine().LineNumber; line++) { if (span.Snapshot.GetLineFromLineNumber(line).GetText().Trim().Length > 0) { edit.Insert(span.Snapshot.GetLineFromLineNumber(line).Start + minindex, format.StartText); } } span = new VirtualSnapshotSpan(new SnapshotSpan(span.Start.Position.GetContainingLine().Start, span.End.Position.GetContainingLine().End)); return(span); }
private static void CommentRegion(SnapshotPoint start, SnapshotPoint end) { ITextSnapshot snapshot = start.Snapshot; using (ITextEdit edit = snapshot.TextBuffer.CreateEdit()) { int column = int.MaxValue; for (int i = start.GetContainingLine().LineNumber; i <= end.GetContainingLine().LineNumber; i++) { string text = snapshot.GetLineFromLineNumber(i).GetText(); int index = GetIndexOfFirstNoneWhiteSpace(text); if (index >= 0 && index < column) { column = index; } } for (int i = start.GetContainingLine().LineNumber; i <= end.GetContainingLine().LineNumber; i++) { ITextSnapshotLine currentLine = snapshot.GetLineFromLineNumber(i); if (string.IsNullOrEmpty(currentLine.GetText())) { continue; } edit.Insert(currentLine.Start.Position + column, "//"); } edit.Apply(); } }
private void FormatSelection(ITextBuffer textBuffer, int insertionIndex, string insertionText) { Controller.TextViewData viewData = Controller.TextViewConnectionListener.GetTextViewDataForBuffer(textBuffer); ITextView textView = viewData.LastActiveView; using (ITextEdit textEdit = textBuffer.CreateEdit()) { textEdit.Insert(insertionIndex, insertionText); textEdit.Apply(); } IOleCommandTarget commandTarget = Shell.Package.GetGlobalService(typeof(Shell.Interop.SUIHostCommandDispatcher)) as IOleCommandTarget; SendFocusToEditor(textView); SnapshotSpan snapshotSpan = new SnapshotSpan(textView.TextSnapshot, insertionIndex, insertionText.Length + 1); textView.Selection.Select(snapshotSpan, false); Guid guidVSStd2K = VSConstants.VSStd2K; commandTarget.Exec( ref guidVSStd2K, (uint)VSConstants.VSStd2KCmdID.FORMATSELECTION, (uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT, IntPtr.Zero, IntPtr.Zero); textView.Selection.Clear(); }
/// <summary> /// Indent the given box selection /// </summary> /// <remarks> /// This is fairly close to the normal text range indenting logic, except that it also /// indents an empty selection at the endline, which the normal text range ignores. /// </remarks> private bool BoxIndent() { string textToInsert = _editorOptions.IsConvertTabsToSpacesEnabled() ? new string(' ', _editorOptions.GetTabSize()) : "\t"; using (ITextEdit edit = TextBuffer.AdvancedTextBuffer.CreateEdit()) { ITextSnapshot snapshot = TextBuffer.AdvancedTextBuffer.CurrentSnapshot; int startLineNumber = GetStartPoint().LineNumber; int endLineNumber = GetEndPoint().LineNumber; for (int i = startLineNumber; i <= endLineNumber; i++) { ITextSnapshotLine line = snapshot.GetLineFromLineNumber(i); if (line.Length > 0) { if (!edit.Insert(line.Start, textToInsert)) { return(false); } } } edit.Apply(); if (edit.Canceled) { return(false); } } return(true); }
private ITextEdit FixByMoving(RobotsTxtLineSyntax line, RobotsTxtRecordSyntax record) { ITextBuffer buffer = line.Record.Document.Snapshot.TextBuffer; // default insertion point at record start SnapshotPoint insertionPoint = record.Span.Start; // find last User-agent line var last = record.Lines .TakeWhile(l => l.NameToken.Value.Equals("User-agent", StringComparison.InvariantCultureIgnoreCase)) .LastOrDefault(); if (last != null) // override insertion point { insertionPoint = last.Span.End.GetContainingLine().EndIncludingLineBreak; } // move line up ITextEdit edit = buffer.CreateEdit(); edit.Insert( insertionPoint, line.Span.Start.GetContainingLine().GetTextIncludingLineBreak() ); edit.Delete(line.Span.Start.GetContainingLine().ExtentIncludingLineBreak); return(edit); }
private void AddTechCallback(object sender, EventArgs e) { ITextBuffer buffer; int selStart, selEnd; string currentCode; bool emptySelection; if (GetBufferAndSelection(out buffer, out selStart, out selEnd, out currentCode, out emptySelection)) { ITextEdit edit = buffer.CreateEdit(); if (emptySelection) { string text = "#if " + GetSelectedTechnology() + Environment.NewLine + Environment.NewLine; if (_includeEndIfComment) { text += "#endif" + GetSelectedTechnologyComment() + Environment.NewLine; } else { text += "#endif" + Environment.NewLine; } edit.Insert(selStart, text); edit.Apply(); } else { string text = "#if " + GetSelectedTechnology() + Environment.NewLine + currentCode + Environment.NewLine; if (_includeEndIfComment) { text += "#endif" + GetSelectedTechnologyComment(); } else { text += "#endif"; } edit.Delete(selStart, selEnd - selStart); edit.Insert(selStart, text); edit.Apply(); } } }
public async Task InsertAsync(string text) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(CancelAllToken); _textEdit.Insert(_position, text); _textEdit.Apply(); _textEdit.Dispose(); }
public ITextSnapshot Insert(int position, string text) { using (ITextEdit textEdit = CreateEdit()) { textEdit.Insert(position, text); return(textEdit.Apply()); } }
protected virtual SnapshotSpan CommentBlock(SnapshotSpan span, ITextEdit edit, BlockCommentFormat format) { Contract.Requires <ArgumentNullException>(edit != null, "edit"); Contract.Requires <ArgumentNullException>(format != null, "format"); //sp. case no selection if (span.IsEmpty) { span = new SnapshotSpan(span.Start.GetContainingLine().Start + ScanToNonWhitespaceChar(span.Start.GetContainingLine()), span.End.GetContainingLine().End); } // add start comment edit.Insert(span.Start, format.StartText); // add end comment edit.Insert(span.End, format.EndText); return(span); }
protected virtual SnapshotSpan CommentBlock(SnapshotSpan span, [NotNull] ITextEdit edit, [NotNull] BlockCommentFormat format) { Requires.NotNull(edit, nameof(edit)); Requires.NotNull(format, nameof(format)); //sp. case no selection if (span.IsEmpty) { span = new SnapshotSpan(span.Start.GetContainingLine().Start + ScanToNonWhitespaceChar(span.Start.GetContainingLine()), span.End.GetContainingLine().End); } // add start comment edit.Insert(span.Start, format.StartText); // add end comment edit.Insert(span.End, format.EndText); return(span); }
private ITextEdit Fix(RobotsTxtLineSyntax line) { ITextBuffer buffer = line.Record.Document.Snapshot.TextBuffer; ITextEdit edit = buffer.CreateEdit(); edit.Insert(line.NameToken.Span.Span.End, RobotsTxtSyntaxFacts.NameValueDelimiter.ToString()); return(edit); }
private void IndentSpan(ITextEdit edit, string indentation, int startLine, int endLine) { var snapshot = _textView.TextBuffer.CurrentSnapshot; for (int i = startLine; i <= endLine; i++) { var curline = snapshot.GetLineFromLineNumber(i); edit.Insert(curline.Start, indentation); } }
private void Unminify(ElementNode element, ITextEdit edit) { for (int i = element.Children.Count - 1; i > -1; i--) { var child = element.Children[i]; Unminify(child, edit); } if (_blockElements.Contains(element.Name)) { int start = element.StartTag.Start; edit.Insert(start, Environment.NewLine); } else if (_blockElements.Contains(element.Parent.Name) && element.Parent.Children.Count > 1) { int start = element.StartTag.Start; edit.Insert(start, Environment.NewLine); } }
public void ExtractVariable() { string selection = view.Selection.SelectedSpans[0].GetText(); ITextSnapshot snapshot = view.TextBuffer.CurrentSnapshot; // Verify the selected text doesn't contain mismatched quotes or braces. if (!hasIntegrity(selection)) { throw new UnrecognisedExpressionException(); } // Check that what comes after is .,);} or operator char next = NextNonWhiteSpaceCharacter(snapshot); if (!permissableFollowing.Contains(next)) { throw new UnrecognisedExpressionException(); } // Check that what comes before is (,= or operator char prev = PreviousNonWhiteSpaceCharacter(snapshot); if (!permissablePreceding.Contains(prev)) { throw new UnrecognisedExpressionException(); } // Get a variable name from the supplied provider. string varName = nameProvider.GetName(); if (varName == null) { return; } int lineNumber = FindLineAfterWhichToInsertDeclaration(snapshot, view.Selection.SelectedSpans[0].Start.Position); if (lineNumber < 0) { throw new FailedInsertionPointException(); } // replace selection with variable name. ITextEdit edit = snapshot.TextBuffer.CreateEdit(); edit.Replace(view.Selection.SelectedSpans[0], varName); int indentSize = GetIndentOfNextNonBlankLine(snapshot, lineNumber); // Add declaration. edit.Insert(snapshot.GetLineFromLineNumber(lineNumber + 1).Start.Position, ("".PadLeft(indentSize) + "var " + varName + " = " + selection + ";\n")); edit.Apply(); }
/// <summary> Adds edits to comment out each non-blank line, at the given column. </summary> void ApplyCommentToNonBlankLines(IEditorOptions options, ITextEdit textEdit, Tuple <ITextSnapshotLine, ITextSnapshotLine> firstAndLastLine, int indentToColumn) { for (int lineNumber = firstAndLastLine.Item1.LineNumber; lineNumber <= firstAndLastLine.Item2.LineNumber; ++lineNumber) { var line = firstAndLastLine.Item1.Snapshot.GetLineFromLineNumber(lineNumber); if (!line.IsEmptyOrWhitespace()) { var offset = line.GetOffsetForColumn(indentToColumn, options.GetTabSize()); textEdit.Insert(line.Start + offset, SyntaxFacts.SingleLineComment); } } }
public void AssignParameterToField() { ITextSnapshot snapshot = view.TextBuffer.CurrentSnapshot; int pos = view.Caret.Position.BufferPosition.Position; Declaration declaration = FindDeclarationNear(snapshot, pos, new char[] { '(', ',' }, new char[] { ',', ')', '=' }); if (declaration == null) { throw new UnrecognisedParameterDeclarationException(); } int assignmentLineNumber = FindLineBeforeWhichToInsertMethodStatement(snapshot, declaration.Span.End); if (assignmentLineNumber < 0) { throw new FailedInsertionPointException("Failed to find insertion point before assignment."); } ITextSnapshotLine assignmentLine = snapshot.GetLineFromLineNumber(assignmentLineNumber); int lineNumber = FindLineAfterWhichToInsertFieldDeclaration(snapshot, assignmentLine.Start.Position); if (lineNumber < 0) { throw new FailedInsertionPointException(); } // add assignment of parameter to method. ITextEdit edit = snapshot.TextBuffer.CreateEdit(); int assignmentIndent = FindIndentOfLine(assignmentLine.GetText()) + TabSize; edit.Insert(assignmentLine.Start.Position, ("".PadLeft(assignmentIndent) + "this." + declaration.VariableName + " = " + declaration.VariableName + ";\n")); // Add declaration. int indentSize = GetIndentOfNextNonBlankLine(snapshot, lineNumber); edit.Insert(snapshot.GetLineFromLineNumber(lineNumber + 1).Start.Position, ("".PadLeft(indentSize) + "private " + declaration.ToString() + ";\n")); edit.Apply(); }
/// <summary> /// Inserts a newline at the end of the file, if it doesn't already exist. /// </summary> /// <param name="snapshot">The snapshot of the document to enforce.</param> /// <param name="edit">The edit context of the document to enforce.</param> /// <param name="eol">The eol character to add.</param> internal void InsertFinalNewline(ITextSnapshot snapshot, ITextEdit edit, string eol) { var line = snapshot.Lines.LastOrDefault(); if (line != null && !string.IsNullOrWhiteSpace(line.GetText())) { if (eol == null) eol = Environment.NewLine; edit.Insert(line.End.Position, eol); } }
protected override void Modify(ITextEdit edit, ITextSnapshotLine line) { edit.Insert(line.Start.Position, "#"); }
private void Unminify(ElementNode element, ITextEdit edit) { for (int i = element.Children.Count - 1; i > -1; i--) { var child = element.Children[i]; Unminify(child, edit); } if (_blockElements.Contains(element.Name)) { int start = element.StartTag.Start; edit.Insert(start, Environment.NewLine); } else if (_blockElements.Contains(element.Parent.Name) && element.Parent.Children.Count > 1) { int start = element.StartTag.Start; edit.Insert(start, Environment.NewLine); } }
private void IndentSpan(ITextEdit edit, string indentation, int startLine, int endLine) { var snapshot = _textView.TextBuffer.CurrentSnapshot; for (int i = startLine; i <= endLine; i++) { var curline = snapshot.GetLineFromLineNumber(i); edit.Insert(curline.Start, indentation); } }
/// <summary> /// Performs an insert in a document. /// </summary> /// <param name="model">The model.</param> private void Insert(DocumentModel doc, OpInsertMessage model, ITextEdit edit) { //doc.BlockEvent = true; var start = model.Index > edit.Snapshot.Length ? edit.Snapshot.Length : model.Index; edit.Insert(start, model.Content); }
/// <summary> /// Undoes a delete operation. /// </summary> /// <param name="model">The model.</param> private void UndoDelete(DocumentModel doc, OpDeleteMessage model, ITextEdit edit) { //doc.BlockEvent = true; edit.Insert(model.Index, model.OldContent); }
protected virtual SnapshotSpan CommentLines(SnapshotSpan span, ITextEdit edit, LineCommentFormat format) { Contract.Requires<ArgumentNullException>(edit != null, "edit"); Contract.Requires<ArgumentNullException>(format != null, "format"); /* * Rules for line comments: * Make sure line comments are indented as far as possible, skipping empty lines as necessary * Don't comment N+1 lines when only N lines were selected my clicking in the left margin */ if (span.End.GetContainingLine().LineNumber > span.Start.GetContainingLine().LineNumber && span.End.GetContainingLine().Start == span.End) { SnapshotPoint start = span.Start; SnapshotPoint end = span.Snapshot.GetLineFromLineNumber(span.End.GetContainingLine().LineNumber - 1).Start; if (end < start) start = end; span = new SnapshotSpan(start, end); } int minindex = (from i in Enumerable.Range(span.Start.GetContainingLine().LineNumber, span.End.GetContainingLine().LineNumber - span.Start.GetContainingLine().LineNumber + 1) where span.Snapshot.GetLineFromLineNumber(i).GetText().Trim().Length > 0 select ScanToNonWhitespaceChar(span.Snapshot.GetLineFromLineNumber(i))) .Min(); //comment each line for (int line = span.Start.GetContainingLine().LineNumber; line <= span.End.GetContainingLine().LineNumber; line++) { if (span.Snapshot.GetLineFromLineNumber(line).GetText().Trim().Length > 0) edit.Insert(span.Snapshot.GetLineFromLineNumber(line).Start + minindex, format.StartText); } span = new SnapshotSpan(span.Start.GetContainingLine().Start, span.End.GetContainingLine().End); return span; }
/// <summary> /// Comment out a span of text using the specified block comment format. If the <paramref name="span"/> is /// empty, the entire line containing the span's start point is commented. /// </summary> /// <param name="span">The span of text to comment.</param> /// <param name="edit">The <see cref="ITextEdit"/> to use for applying changes.</param> /// <param name="format">The block comment format.</param> /// <returns>A <see cref="VirtualSnapshotSpan"/> containing the commented code.</returns> /// <exception cref="ArgumentNullException"> /// <para>If <paramref name="edit"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para>If <paramref name="format"/> is <see langword="null"/>.</para> /// </exception> protected virtual VirtualSnapshotSpan CommentBlock(VirtualSnapshotSpan span, ITextEdit edit, BlockCommentFormat format) { Contract.Requires<ArgumentNullException>(edit != null, "edit"); Contract.Requires<ArgumentNullException>(format != null, "format"); //special case no selection if (span.IsEmpty) { VirtualSnapshotPoint start = new VirtualSnapshotPoint(span.Start.Position.GetContainingLine().Start + ScanToNonWhitespaceChar(span.Start.Position.GetContainingLine())); VirtualSnapshotPoint end = span.IsInVirtualSpace ? span.End : new VirtualSnapshotPoint(span.End.Position.GetContainingLine().End); span = new VirtualSnapshotSpan(start, end); } // add start comment edit.Insert(span.Start.Position, format.StartText); // add end comment edit.Insert(span.End.Position, format.EndText); return span; }
/// <summary> /// Comment out a span using a particular line comment format. If the <paramref name="span"/> is empty, the /// entire line containing the span's start point is commented. /// </summary> /// <remarks> /// <para>The default algorithm for line comments is designed to meet the following conditions.</para> /// <list type="bullet"> /// <item>Make sure line comments are indented as far as possible, skipping empty lines as necessary.</item> /// <item>Don't comment <em>N</em>+1 lines when only <em>N</em> lines were selected by clicking in the left /// margin.</item> /// </list> /// </remarks> /// <param name="span">The span of text to comment.</param> /// <param name="edit">The <see cref="ITextEdit"/> to apply the changes to.</param> /// <param name="format">The line comment format to use for commenting the code.</param> /// <returns>A <see cref="VirtualSnapshotSpan"/> containing the commented code.</returns> /// <exception cref="ArgumentNullException"> /// <para>If <paramref name="edit"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para>If <paramref name="format"/> is <see langword="null"/>.</para> /// </exception> protected virtual VirtualSnapshotSpan CommentLines(VirtualSnapshotSpan span, ITextEdit edit, LineCommentFormat format) { Contract.Requires<ArgumentNullException>(edit != null, "edit"); Contract.Requires<ArgumentNullException>(format != null, "format"); if (span.End.Position.GetContainingLine().LineNumber > span.Start.Position.GetContainingLine().LineNumber && span.End.Position.GetContainingLine().Start == span.End.Position) { VirtualSnapshotPoint start = span.Start; VirtualSnapshotPoint end = new VirtualSnapshotPoint(span.Snapshot.GetLineFromLineNumber(span.End.Position.GetContainingLine().LineNumber - 1).Start); if (end < start) start = end; span = new VirtualSnapshotSpan(start, end); } int minindex = (from i in Enumerable.Range(span.Start.Position.GetContainingLine().LineNumber, span.End.Position.GetContainingLine().LineNumber - span.Start.Position.GetContainingLine().LineNumber + 1) where span.Snapshot.GetLineFromLineNumber(i).GetText().Trim().Length > 0 select ScanToNonWhitespaceChar(span.Snapshot.GetLineFromLineNumber(i))) .Min(); //comment each line for (int line = span.Start.Position.GetContainingLine().LineNumber; line <= span.End.Position.GetContainingLine().LineNumber; line++) { if (span.Snapshot.GetLineFromLineNumber(line).GetText().Trim().Length > 0) edit.Insert(span.Snapshot.GetLineFromLineNumber(line).Start + minindex, format.StartText); } span = new VirtualSnapshotSpan(new SnapshotSpan(span.Start.Position.GetContainingLine().Start, span.End.Position.GetContainingLine().End)); return span; }
protected virtual SnapshotSpan CommentBlock(SnapshotSpan span, ITextEdit edit, BlockCommentFormat format) { Contract.Requires<ArgumentNullException>(edit != null, "edit"); Contract.Requires<ArgumentNullException>(format != null, "format"); //sp. case no selection if (span.IsEmpty) { span = new SnapshotSpan(span.Start.GetContainingLine().Start + ScanToNonWhitespaceChar(span.Start.GetContainingLine()), span.End.GetContainingLine().End); } // add start comment edit.Insert(span.Start, format.StartText); // add end comment edit.Insert(span.End, format.EndText); return span; }
private void ReplaceLines(ITextEdit edit, int startOldLine, int endOldLine, int startNewLine, int endNewLine) { int oldLineCount = endOldLine - startOldLine; int newLineCount = endNewLine - startNewLine; // replace one line at a time instead of all of the lines at once so that we preserve breakpoints int excessNewLineStart = startNewLine - startOldLine; for (int i = startOldLine; i < endOldLine && i < (endNewLine - startNewLine + startOldLine); i++) { edit.Replace( _snapshot.GetLineFromLineNumber(_startingReplacementLine + i).Extent, _newLines[startNewLine + i - startOldLine] ); excessNewLineStart = startNewLine + i - startOldLine + 1; } if (oldLineCount > newLineCount) { // we end up w/ less lines, we need to delete some text edit.Delete( Span.FromBounds( _snapshot.GetLineFromLineNumber(_startingReplacementLine + endOldLine - (oldLineCount - newLineCount)).Start.Position, _snapshot.GetLineFromLineNumber(_startingReplacementLine + endOldLine - 1).EndIncludingLineBreak.Position ) ); } else if (oldLineCount < newLineCount) { // we end up w/ more lines, we need to insert some text edit.Insert( _snapshot.GetLineFromLineNumber(_startingReplacementLine + endOldLine - 1).EndIncludingLineBreak, string.Join( _view.Options.GetNewLineCharacter(), _newLines, excessNewLineStart, endNewLine - excessNewLineStart ) + _view.Options.GetNewLineCharacter() ); } }