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) { } } } }
/// Takes current text buffer and new text then builds list of changed /// regions and applies them to the buffer. This way we can avoid /// destruction of bookmarks and other markers. Complete /// buffer replacement deletes all markers which causes /// loss of bookmarks, breakpoints and other similar markers. public static void ApplyChange( ITextBuffer textBuffer, int position, int length, string newText, string transactionName, ISelectionTracker selectionTracker, int maxMilliseconds) { var snapshot = textBuffer.CurrentSnapshot; int oldLength = Math.Min(length, snapshot.Length - position); string oldText = snapshot.GetText(position, oldLength); var changes = TextChanges.BuildChangeList(oldText, newText, maxMilliseconds); if (changes != null && changes.Count > 0) { using (var selectionUndo = new SelectionUndo(selectionTracker, transactionName, automaticTracking: false)) { using (ITextEdit edit = textBuffer.CreateEdit()) { // Replace ranges in reverse so relative positions match for (int i = changes.Count - 1; i >= 0; i--) { TextChange tc = changes[i]; edit.Replace(tc.Position + position, tc.Length, tc.NewText); } edit.Apply(); } } } }
static void DeleteExistingDefinition(ITextSnapshot snapshot, Parser.Result result) { DTE2 dte = Global.GetDTE2(); ITextEdit edit = snapshot.TextBuffer.CreateEdit(); try { ITextSnapshotLine currentLine; for (int i = result.StartLine - 1; i <= result.EndLine - 1; i++) { currentLine = snapshot.GetLineFromLineNumber(i); edit.Delete(currentLine.Start.Position, currentLine.LengthIncludingLineBreak); } //remove separating empty line if found if (snapshot.LineCount > result.EndLine) { currentLine = snapshot.GetLineFromLineNumber(result.EndLine); if (string.IsNullOrWhiteSpace(currentLine.GetText())) { edit.Delete(currentLine.Start.Position, currentLine.LengthIncludingLineBreak); } } edit.Apply(); } catch { edit.Cancel(); } dte.ActiveDocument.Save(); }
private void UpdateVendorValues(ParseItem item) { Declaration dec = item.FindType <Declaration>(); if (dec != null && Cache.Contains(dec) && !dec.IsVendorSpecific()) { // Find all vendor specifics that isn't the standard property. var matches = Cache.Where(d => d.IsValid && d != dec && d.Parent == dec.Parent && GetStandardName(d) == dec.PropertyName.Text && d.PropertyName.Text != dec.PropertyName.Text); // Undo sometimes messes with the positions, so we have to make this check before proceeding. if (!matches.Any() || dec.Text.Length < dec.Colon.AfterEnd - dec.Start || dec.Colon.AfterEnd < dec.Start) { return; } string text = dec.Text.Substring(dec.Colon.AfterEnd - dec.Start, dec.AfterEnd - dec.Colon.AfterEnd); using (ITextEdit edit = _buffer.CreateEdit()) { foreach (Declaration match in matches.Reverse()) { SnapshotSpan span = new SnapshotSpan(_buffer.CurrentSnapshot, match.Colon.AfterEnd, match.AfterEnd - match.Colon.AfterEnd); if (span.GetText() != text) { edit.Replace(span, text); } } edit.Apply(); } } }
public void SuppressError(string errorCode) { if (string.IsNullOrEmpty(errorCode) || _document.Suppressions.Contains(errorCode)) { return; } var range = new Span(0, 0); IEnumerable <string> errorCodes = _document.Suppressions.Union(new[] { errorCode }).OrderBy(c => c); if (_document.Suppressions.Any()) { int position = _document.ParseItems.First().Span.Start; ITextSnapshotLine line = _document.TextBuffer.CurrentSnapshot.GetLineFromPosition(position); range = Span.FromBounds(line.Start, line.EndIncludingLineBreak); } string text = string.Format("# Suppress: {0}", string.Join(" ", errorCodes)) + Environment.NewLine; using (ITextEdit edit = _document.TextBuffer.CreateEdit()) { edit.Replace(range, text); edit.Apply(); } }
public async override void Invoke(CancellationToken cancellationToken) { ImageCompressor compressor = new ImageCompressor(); bool isDataUri = Attribute.Value.StartsWith("data:image/", StringComparison.Ordinal); if (isDataUri) { string dataUri = await compressor.CompressDataUriAsync(Attribute.Value); if (dataUri.Length < Attribute.Value.Length) { using (WebEssentialsPackage.UndoContext(this.DisplayText)) using (ITextEdit edit = TextBuffer.CreateEdit()) { Span span = Span.FromBounds(Attribute.ValueRangeUnquoted.Start, Attribute.ValueRangeUnquoted.End); edit.Replace(span, dataUri); edit.Apply(); } } } else { var fileName = ImageQuickInfo.GetFullUrl(Attribute.Value, TextBuffer); if (string.IsNullOrEmpty(fileName) || !ImageCompressor.IsFileSupported(fileName) || !File.Exists(fileName)) { return; } await compressor.CompressFilesAsync(fileName); } }
private void RemoveTrailingWhitespace(ITextBuffer buffer) { bool foundWhitespace = false; using (ITextEdit edit = buffer.CreateEdit()) { ITextSnapshot snap = edit.Snapshot; foreach (ITextSnapshotLine line in snap.Lines) { string text = line.GetText(); int length = text.Length; while (--length >= 0 && Char.IsWhiteSpace(text[length])) { ; } if (length < text.Length - 1) { int start = line.Start.Position; edit.Delete(start + length + 1, text.Length - length - 1); foundWhitespace = true; } } edit.Apply(); } if (foundWhitespace) { Telemetry.TrackEvent("On save"); } }
/// <inheritdoc /> public void Commit() { if (!session.SelectedCompletionSet.SelectionStatus.IsSelected) { return; } ITrackingSpan applicableTo = session.SelectedCompletionSet.ApplicableTo; using (ITextEdit edit = applicableTo.TextBuffer.CreateEdit()) { // The insertion text is inserted without the \xFF character (if any) string insertionText = InsertionText.Replace("\xFF", ""); edit.Replace(applicableTo.GetSpan(edit.Snapshot), insertionText); ITextSnapshot applied = edit.Apply(); // The original position of the \xFF character determines the placement of the caret int caretOffset = InsertionText.IndexOf('\xFF'); if (caretOffset >= 0) { SnapshotPoint startPoint = applicableTo.GetStartPoint(applied); SnapshotPoint caretPoint = startPoint + caretOffset; session.TextView.Caret.MoveTo(caretPoint, PositionAffinity.Predecessor); } } }
public override bool Capitalize() { int startPosition = _startPoint.CurrentPosition; if (IsEmpty) { int endPosition = _endPoint.CurrentPosition; TextRange currentWord = _startPoint.GetCurrentWord(); string nextCharacter = _startPoint.GetNextCharacter(); if (_startPoint.CurrentPosition == currentWord.GetStartPoint().CurrentPosition) { nextCharacter = nextCharacter.ToUpper(CultureInfo.CurrentCulture); } else { nextCharacter = nextCharacter.ToLower(CultureInfo.CurrentCulture); } if (!PrimitivesUtilities.Replace(TextBuffer.AdvancedTextBuffer, new Span(_startPoint.CurrentPosition, nextCharacter.Length), nextCharacter)) { return(false); } _endPoint.MoveTo(endPosition); } else { using (ITextEdit edit = TextBuffer.AdvancedTextBuffer.CreateEdit()) { TextRange currentWord = _startPoint.GetCurrentWord(); // If the current word extends past this range, go to the next word if (currentWord.GetStartPoint().CurrentPosition < _startPoint.CurrentPosition) { currentWord = currentWord.GetEndPoint().GetNextWord(); } while (currentWord.GetStartPoint().CurrentPosition < _endPoint.CurrentPosition) { string wordText = currentWord.GetText(); string startElement = StringInfo.GetNextTextElement(wordText); wordText = startElement.ToUpper(CultureInfo.CurrentCulture) + wordText.Substring(startElement.Length).ToLower(CultureInfo.CurrentCulture); if (!edit.Replace(currentWord.AdvancedTextRange.Span, wordText)) { edit.Cancel(); return(false); } currentWord = currentWord.GetEndPoint().GetNextWord(); } edit.Apply(); if (edit.Canceled) { return(false); } } } _startPoint.MoveTo(startPosition); return(true); }
/// <summary> /// Removes white space from both ends of a line. /// </summary> private void StripWhiteSpace(ITextSnapshotLine line) { ITextSnapshot snapshot = line.Snapshot; ITextBuffer buffer = snapshot.TextBuffer; int forwardIterator; int backwardIterator; // Detect spaces at the beginning forwardIterator = line.Start.Position; while (forwardIterator < line.End.Position && IsSpaceCharacter(snapshot[forwardIterator])) { ++forwardIterator; } // Detect spaces at the end backwardIterator = line.End.Position - 1; while (backwardIterator > forwardIterator && IsSpaceCharacter(snapshot[backwardIterator])) { --backwardIterator; } if ((backwardIterator != line.End.Position - 1) || (forwardIterator != line.Start.Position)) { using (ITextEdit edit = buffer.CreateEdit()) { edit.Delete(Span.FromBounds(backwardIterator + 1, line.End.Position)); edit.Delete(Span.FromBounds(line.Start.Position, forwardIterator)); edit.Apply(); } } }
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); }
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); }
/// <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); }
public override void Invoke(CancellationToken cancellationToken) { string mimeType = FileHelpers.GetMimeTypeFromBase64(Attribute.Value); string extension = FileHelpers.GetExtension(mimeType) ?? "png"; string fileName = FileHelpers.ShowDialog(extension); if (!string.IsNullOrEmpty(fileName) && FileHelpers.SaveDataUriToFile(Attribute.Value, fileName)) { string relative = FileHelpers.RelativePath(TextBuffer.GetFileName(), fileName); try { ProjectHelpers.DTE.UndoContext.Open(DisplayText); using (ITextEdit edit = TextBuffer.CreateEdit()) { edit.Replace(Attribute.ValueRangeUnquoted.ToSpan(), relative.ToLowerInvariant()); edit.Apply(); } } finally { ProjectHelpers.DTE.UndoContext.Close(); } } }
/// <summary> /// Undo the text buffer change action. /// </summary> /// <exception cref="InvalidOperationException">Operation cannot be undone.</exception> public override void Undo() { // Validate that we can undo this change if (!CanUndo) { throw new InvalidOperationException(Strings.CannotUndo); } #if DEBUG // sanity check Debug.Assert(TextBuffer.CurrentSnapshot.Length == _bufferLengthAfterChange, "The buffer is in a different state than when this TextBufferUndoChangePrimitive was created!"); #endif // For undo-in-closed-files scenarios where we are done/undone on a buffer other // than the one we were originally created on. if (AttachedToNewBuffer) { AttachedToNewBuffer = false; _beforeVersion = null; _afterVersion = TextBuffer.CurrentSnapshot.Version.VersionNumber; } bool editCanceled = false; using (ITextEdit edit = TextBuffer.CreateEdit(EditOptions.None, _beforeVersion, typeof(TextBufferChangeUndoPrimitive))) { foreach (ITextChange textChange in _textChanges) { if (!edit.Replace(new Span(textChange.NewPosition, textChange.NewLength), textChange.OldText)) { // undo canceled by readonly region editCanceled = true; break; } } if (!editCanceled) { edit.Apply(); if (edit.Canceled) { editCanceled = true; } } } if (editCanceled) { throw new OperationCanceledException("Undo failed due to readonly regions or canceled edit."); } if (_beforeVersion == null) { _beforeVersion = TextBuffer.CurrentSnapshot.Version.VersionNumber; } _canUndo = false; }
private void StripWhiteSpace(ITextSnapshotLine line) { ITextSnapshot snapshot = line.Snapshot; ITextBuffer textBuffer = snapshot.TextBuffer; int position = line.Start.Position; while (position < line.End.Position && IsSpaceCharacter(snapshot[position])) { ++position; } int index = line.End.Position - 1; while (index > position && IsSpaceCharacter(snapshot[index])) { --index; } if (index == line.End.Position - 1 && position == line.Start.Position) { return; } using (ITextEdit edit = textBuffer.CreateEdit()) { edit.Delete(Span.FromBounds(index + 1, line.End.Position)); edit.Delete(Span.FromBounds(line.Start.Position, position)); edit.Apply(); } }
private async Task <bool> MakePrettierAsync() { string input = _view.TextBuffer.CurrentSnapshot.GetText(); string output = await _node.ExecuteProcessAsync(input, _encoding, _filePath); VirtualSnapshotPoint snapshotPoint = _view.Selection.ActivePoint; if (string.IsNullOrEmpty(output) || input == output) { return(false); } using (ITextEdit edit = _view.TextBuffer.CreateEdit()) using (ITextUndoTransaction undo = _undoManager.TextBufferUndoHistory.CreateTransaction("Make Prettier")) { edit.Replace(0, _view.TextBuffer.CurrentSnapshot.Length, output); edit.Apply(); undo.Complete(); } var newSnapshotPoint = new SnapshotPoint(_view.TextBuffer.CurrentSnapshot, snapshotPoint.Position.Position); _view.Caret.MoveTo(newSnapshotPoint); _view.ViewScroller.EnsureSpanVisible(new SnapshotSpan(newSnapshotPoint, 0)); return(true); }
public override void Invoke(CancellationToken cancellationToken) { var content = Element.GetText(Element.InnerRange).Trim(); int start = Element.Start; int length = content.Length; try { ProjectHelpers.DTE.UndoContext.Open(DisplayText); using (ITextEdit edit = TextBuffer.CreateEdit()) { edit.Replace(Element.OuterRange.ToSpan(), content); edit.Apply(); } SnapshotSpan span = new SnapshotSpan(TextView.TextBuffer.CurrentSnapshot, start, length); TextView.Selection.Select(span, false); ProjectHelpers.DTE.ExecuteCommand("Edit.FormatSelection"); TextView.Caret.MoveTo(new SnapshotPoint(TextView.TextBuffer.CurrentSnapshot, start)); TextView.Selection.Clear(); } finally { ProjectHelpers.DTE.UndoContext.Close(); } }
private async Task MakeChanges(string root, string fileName) { string text = Element.GetText(Element.InnerRange).Trim(); string reference = GetReference(Element, fileName, root); try { ProjectHelpers.DTE.UndoContext.Open(DisplayText); using (ITextEdit edit = TextBuffer.CreateEdit()) { edit.Replace(new Span(Element.Start, Element.Length), reference); edit.Apply(); } File.WriteAllText(fileName, text); ProjectHelpers.AddFileToActiveProject(fileName); ProjectHelpers.DTE.ItemOperations.OpenFile(fileName); await Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => { ProjectHelpers.DTE.ExecuteCommand("Edit.FormatDocument"); }), DispatcherPriority.ApplicationIdle, null); } finally { ProjectHelpers.DTE.UndoContext.Close(); } }
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(); }
public override void Invoke(CancellationToken cancellationToken) { if (_disabled) { return; } try { var dependencies = Dependencies.FromConfigFile(_provider.ConfigFilePath); IProvider provider = dependencies.GetProvider(_provider.InstallationState.ProviderId); ILibraryCatalog catalog = provider?.GetCatalog(); if (catalog == null) { return; } JSONMember member = _provider.LibraryObject.Children.OfType <JSONMember>().FirstOrDefault(m => m.UnquotedNameText == "id"); if (member != null) { using (ITextEdit edit = TextBuffer.CreateEdit()) { edit.Replace(new Span(member.Value.Start, member.Value.Length), "\"" + _updatedLibraryId + "\""); edit.Apply(); } } } catch (Exception ex) { Logger.LogEvent(ex.ToString(), LogLevel.Error); } }
public override async void Invoke(CancellationToken cancellationToken) { try { await LibraryHelpers.UninstallAsync(_provider.ConfigFilePath, _provider.InstallationState.LibraryId, cancellationToken).ConfigureAwait(false); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); using (ITextEdit edit = TextBuffer.CreateEdit()) { var arrayElement = _provider.LibraryObject.Parent as JSONArrayElement; var prev = arrayElement.PreviousSibling as JSONArrayElement; var next = arrayElement.NextSibling as JSONArrayElement; int start = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.Start).Start; int end = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.AfterEnd).EndIncludingLineBreak; if (next == null && prev?.Comma != null) { start = prev.Comma.Start; end = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.AfterEnd).End; } edit.Delete(Span.FromBounds(start, end)); edit.Apply(); } } catch (Exception ex) { Logger.LogEvent(ex.ToString(), Microsoft.Web.LibraryManager.Contracts.LogLevel.Error); } }
private void CreateNewCommentLine(ITextChange change) { using (ITextEdit editor = this._view.TextBuffer.CreateEdit()) { try { ITextSnapshotLine line = this._view.TextSnapshot.GetLineFromPosition(change.OldEnd); string lineText = line.GetText(); string nextLine = this._view.TextSnapshot.GetLineFromLineNumber(line.LineNumber + 1).GetText(); if (commentLineStart.IsMatch(lineText) && (commentLineStart.IsMatch(nextLine) || change.OldEnd != line.End.Position)) { int asteriskIndex = lineText.IndexOf('*'); //Only add a new comment line if the newline char is after the triple slash //(how Visual Studio in C# works) if ((line.Start.Position + asteriskIndex) > change.OldEnd) { return; } int tabsStopIndex = -1; if (asteriskIndex >= 0 || lineText.Contains("/**")) { // There's no slash, or its open-comment line, so it's a jsdoc comment. We need asteriskIndex here. tabsStopIndex = asteriskIndex; } string newTabs = tabsStopIndex >= 0 ? lineText.Substring(0, tabsStopIndex) : ""; newTabs = newTabs.Replace('/', ' '); editor.Replace(change.NewSpan, Environment.NewLine + newTabs + "* "); editor.Apply(); } } catch (Exception) { } } }
internal override void Execute(EmacsCommandContext context) { SnapshotSpan?previousWord = context.TextStructureNavigator.GetPreviousWord(context.TextView); if (!previousWord.HasValue || !previousWord.Value.IntersectsWith(new Span(context.TextView.GetCaretPosition(), 1))) { return; } SnapshotSpan?nextWord = context.TextStructureNavigator.GetNextWord(previousWord.Value.End); if (!nextWord.HasValue) { return; } string text1 = context.TextView.TextSnapshot.GetText(previousWord.Value); string text2 = context.TextView.TextSnapshot.GetText(nextWord.Value); using (ITextEdit edit = context.TextView.TextBuffer.CreateEdit()) { edit.Replace(nextWord.Value, text1); edit.Replace(previousWord.Value, text2); edit.Apply(); } context.TextView.Caret.MoveTo(new SnapshotPoint(context.TextView.TextSnapshot, nextWord.Value.End)); context.TextView.Caret.EnsureVisible(); }
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(); }
private bool Format(SnapshotSpan span) { if (span.Snapshot.TextBuffer != this.textBuffer || span.IsEmpty || !this.CanFormatSpan(span)) { return(false); } SnapshotPoint startLinePoint = span.Start.GetContainingLine().Start; span = new SnapshotSpan(startLinePoint, span.End); SourceText sourceText = this.core.SourceTextCache.Get(this.textBuffer.CurrentSnapshot); Range range = new Range(span.Start.Position, span.Length); FormattingOptions formattingOptions = this.GetFormattingOptions(this.core.FormattingUserSettings); List <TextEditInfo> edits = this.core.FeatureContainer.Formatter.Format(sourceText, range, formattingOptions); using (ITextEdit textEdit = this.textBuffer.CreateEdit()) { foreach (TextEditInfo edit in edits) { textEdit.Replace(edit.Start, edit.Length, edit.ReplacingWith); } textEdit.Apply(); } return(true); }
private static void UnCommentRegion(SnapshotPoint start, SnapshotPoint end) { ITextSnapshot snapshot = start.Snapshot; using (ITextEdit edit = snapshot.TextBuffer.CreateEdit()) { for (int i = start.GetContainingLine().LineNumber; i <= end.GetContainingLine().LineNumber; i++) { ITextSnapshotLine currentLine = snapshot.GetLineFromLineNumber(i); string lineText = currentLine.GetText(); for (int j = 0; j < lineText.Length - 1; j++) { if (!char.IsWhiteSpace(lineText[j])) { if (lineText[j] == '/' && lineText[j + 1] == '/') { edit.Delete(currentLine.Start.Position + j, 2); break; } } } } edit.Apply(); } }
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(); } }
public void Edit(Project project) { string str = Path.Combine(ProjectExtensions.GetFullPath(project), "web.config"); if (project.DTE.SourceControl.IsItemUnderSCC(str) && !project.DTE.SourceControl.IsItemCheckedOut(str) && !project.DTE.SourceControl.CheckOutItem(str)) { return; } IEditorInterfaces orOpenDocument = this.VisualStudio.Editor.GetOrOpenDocument(str); Marshal.ThrowExceptionForHR(orOpenDocument.VsTextBuffer.Reload(1)); ITextBuffer textBuffer = orOpenDocument.TextBuffer; using (ITextEdit textEdit = textBuffer.CreateEdit()) { string editedText = this.GetEditedText(textEdit.Snapshot.GetText()); if (editedText != null) { textEdit.Replace(new Span(0, textBuffer.CurrentSnapshot.Length), editedText); textEdit.Apply(); this.VisualStudio.Editor.FormatDocument(str); Document document = project.DTE.Documents.Item(str); document.Save(""); } } }
private int SwapItemWithNextSibling(ParseItem item, ITextEdit edit) { RuleSet next = item.NextSibling as RuleSet; if (next == null) return -1; ITextSnapshot snapshot = _textView.TextBuffer.CurrentSnapshot; string whitespace = snapshot.GetText(item.AfterEnd, next.Start - item.AfterEnd); string text = next.Text + whitespace + item.Text; edit.Replace(item.Start, next.AfterEnd - item.Start, text); edit.Apply(); return item.Start + next.Length + whitespace.Length; }
private static ITextSnapshot ApplyEdit(ITextEdit edit) { using (edit) return edit.Apply(); }