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);
}
private bool InvokeZenCoding()
{
ThreadHelper.ThrowIfNotOnUIThread();
Span zenSpan = GetSyntaxSpan(out string syntax);
if (zenSpan.IsEmpty || _view.Selection.SelectedSpans[0].Length > 0 || !IsValidTextBuffer())
{
return(false);
}
var parser = new Parser();
string result = parser.Parse(syntax, ZenType.HTML);
if (!string.IsNullOrEmpty(result))
{
using (ITextUndoTransaction undo = _undoManager.TextBufferUndoHistory.CreateTransaction("ZenCoding"))
{
ITextSelection selection = UpdateTextBuffer(zenSpan, result);
var newSpan = new Span(zenSpan.Start, selection.SelectedSpans[0].Length);
_dte.ExecuteCommand("Edit.FormatSelection");
SetCaret(newSpan, false);
selection.Clear();
undo.Complete();
}
return(true);
}
return(false);
}
private void DeleteSpan(NormalizedSnapshotSpanCollection applicabilitySpans)
{
using (ITextUndoTransaction undoTransaction = _undoHistory.CreateTransaction("HTML Cut"))
{
_editorOperations.AddBeforeTextBufferChangePrimitive();
bool successfulEdit = true;
using (ITextEdit edit = _textView.TextBuffer.CreateEdit())
{
foreach (SnapshotSpan span in applicabilitySpans)
{
successfulEdit &= edit.Delete(span);
}
if (successfulEdit)
{
edit.Apply();
}
}
_editorOperations.AddAfterTextBufferChangePrimitive();
if (successfulEdit)
{
undoTransaction.Complete();
}
}
}
public UndoTransactionImpl(ITextUndoHistory history, ITextUndoTransaction parent, string description)
{
if (history == null)
{
throw new ArgumentNullException(nameof(history));
}
if (string.IsNullOrEmpty(description))
{
throw new ArgumentNullException(nameof(description));
}
this.history = history as UndoHistoryImpl;
if (this.history == null)
{
throw new ArgumentException("Strings.InvalidHistoryInTransaction");
}
this.parent = parent as UndoTransactionImpl;
if (this.parent == null && parent != null)
{
throw new ArgumentException("Strings.InvalidParentInTransaction");
}
this.description = description;
this.state = UndoTransactionState.Open;
this.primitives = new List <ITextUndoPrimitive>();
this.mergePolicy = NullMergeUndoTransactionPolicy.Instance;
this.IsReadOnly = true;
}
public void OnCharTyped(char @char)
{
// format on ':'
if (@char == RobotsTxtSyntaxFacts.NameValueDelimiter)
{
ITextBuffer buffer = _textView.TextBuffer;
SyntaxTree syntaxTree = buffer.GetSyntaxTree();
RobotsTxtDocumentSyntax root = syntaxTree.Root as RobotsTxtDocumentSyntax;
// find in syntax tree
var caret = _textView.Caret.Position.BufferPosition;
RobotsTxtLineSyntax lineSyntax = root.Records
.SelectMany(r => r.Lines)
.FirstOrDefault(p => p.DelimiterToken.Span.Span.End == caret);
if (lineSyntax != null)
{
using (ITextUndoTransaction transaction = _undoHistory.CreateTransaction("Automatic Formatting"))
{
using (ITextEdit edit = buffer.CreateEdit())
{
// fix indent
// find property before
RobotsTxtLineSyntax before = lineSyntax.Record.Lines
.TakeWhile(p => p != lineSyntax)
.LastOrDefault();
// reference point
if (before != null)
{
SnapshotPoint referencePoint = before.NameToken.Span.Span.Start;
// compare
ITextSnapshotLine referenceLine = referencePoint.GetContainingLine();
ITextSnapshotLine line = lineSyntax.DelimiterToken.Span.Span.End.GetContainingLine();
SnapshotSpan referenceIndent = new SnapshotSpan(referenceLine.Start, referencePoint);
SnapshotSpan indent = new SnapshotSpan(line.Start, lineSyntax.NameToken.Span.Span.Start);
if (indent.GetText() != referenceIndent.GetText())
{
edit.Replace(indent, referenceIndent.GetText());
}
}
// remove white space before ':'
if (lineSyntax.NameToken.Span.Span.End != lineSyntax.DelimiterToken.Span.Span.Start)
{
edit.Delete(new SnapshotSpan(lineSyntax.NameToken.Span.Span.End, lineSyntax.DelimiterToken.Span.Span.Start));
}
edit.Apply();
}
transaction.Complete();
}
}
}
}
public bool ValidTransactionForMarkers(ITextUndoTransaction transaction)
{
return(transaction == null || //// you can put a marker on the null transaction
_currentTransaction == transaction || //// you can put a marker on the currently active transaction
(transaction.History == this && transaction.State != UndoTransactionState.Invalid));
//// and you can put a marker on any transaction in this history.
}
public UndoTransactionImpl(ITextUndoHistory history, ITextUndoTransaction parent, string description) {
if (history == null) {
throw new ArgumentNullException(nameof(history));
}
if (string.IsNullOrEmpty(description)) {
throw new ArgumentNullException(nameof(description));
}
_history = history as UndoHistoryImpl;
if (_history == null) {
throw new ArgumentException("Invalid history in registry");
}
_parent = parent as UndoTransactionImpl;
if (_parent == null && parent != null) {
throw new ArgumentException("Invalid parent in transaction");
}
Description = description;
_state = UndoTransactionState.Open;
_primitives = new List<ITextUndoPrimitive>();
_mergePolicy = NullMergeUndoTransactionPolicy.Instance;
IsReadOnly = true;
}
public UndoTransactionImpl(ITextUndoHistory history, ITextUndoTransaction parent, string description)
{
if (history == null)
{
throw new ArgumentNullException(nameof(history));
}
if (string.IsNullOrEmpty(description))
{
throw new ArgumentNullException(nameof(description));
}
_history = history as UndoHistoryImpl;
if (_history == null)
{
throw new ArgumentException("Invalid history in registry");
}
_parent = parent as UndoTransactionImpl;
if (_parent == null && parent != null)
{
throw new ArgumentException("Invalid parent in transaction");
}
Description = description;
_state = UndoTransactionState.Open;
_primitives = new List <ITextUndoPrimitive>();
_mergePolicy = NullMergeUndoTransactionPolicy.Instance;
IsReadOnly = true;
}
public bool CanMerge(ITextUndoTransaction newTransaction, ITextUndoTransaction oldTransaction)
{
// Validate
if (newTransaction == null)
{
throw new ArgumentNullException(nameof(newTransaction));
}
if (oldTransaction == null)
{
throw new ArgumentNullException(nameof(oldTransaction));
}
TextTransactionMergePolicy oldPolicy = oldTransaction.MergePolicy as TextTransactionMergePolicy;
TextTransactionMergePolicy newPolicy = newTransaction.MergePolicy as TextTransactionMergePolicy;
if (oldPolicy == null || newPolicy == null)
{
throw new InvalidOperationException("The MergePolicy for both transactions should be a TextTransactionMergePolicy.");
}
// Make sure the merge policy directions permit merging these two transactions.
if ((oldPolicy._allowableMergeDirections & TextTransactionMergeDirections.Forward) == 0 ||
(newPolicy._allowableMergeDirections & TextTransactionMergeDirections.Backward) == 0)
{
return false;
}
// Only merge text transactions that have the same description
if (newTransaction.Description != oldTransaction.Description)
{
return false;
}
return true;
}
private void OnTransactionStackCompleted(BasicUndoTransaction transaction)
{
Debug.Assert(_openTransactionStack.Count == 0);
ITextUndoTransaction eventArgument = transaction;
var result = TextUndoTransactionCompletionResult.TransactionAdded;
if (_undoStack.Count > 0)
{
var previous = _undoStack.Peek();
if (transaction.MergePolicy != null &&
previous.MergePolicy != null &&
previous.MergePolicy.TestCompatiblePolicy(transaction.MergePolicy) &&
previous.MergePolicy.CanMerge(newerTransaction: transaction, olderTransaction: previous))
{
eventArgument = previous;
previous.MergePolicy.PerformTransactionMerge(existingTransaction: previous, newTransaction: transaction);
}
else
{
_undoStack.Push(transaction);
}
}
else
{
_undoStack.Push(transaction);
}
var list = _undoTransactionCompleted;
if (list != null)
{
list(this, new TextUndoTransactionCompletedEventArgs(eventArgument, result));
}
}
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);
}
public TextUndoTransaction(TextUndoHistory textUndoHistory, ITextUndoTransaction parent)
{
_textUndoHistory = textUndoHistory;
_state = UndoTransactionState.Open;
_parent = parent;
MergePolicy = new Policy();
}
public bool CanMerge(ITextUndoTransaction newTransaction, ITextUndoTransaction oldTransaction)
{
MergeUndoActionPolicy oldPolicy = oldTransaction.MergePolicy as MergeUndoActionPolicy;
MergeUndoActionPolicy newPolicy = newTransaction.MergePolicy as MergeUndoActionPolicy;
if (oldPolicy != null && oldPolicy._mergeNext &&
newPolicy != null && newPolicy._mergePrevious &&
oldPolicy._actionName == newPolicy._actionName)
{
// If one of the transactions is empty, than it is safe to merge
if (newTransaction.UndoPrimitives.Count == 0 ||
oldTransaction.UndoPrimitives.Count == 0)
{
return(true);
}
// Make sure that we only merge consecutive edits
ITextUndoPrimitive newPrimitive = newTransaction.UndoPrimitives[0];
ITextUndoPrimitive oldPrimitive = oldTransaction.UndoPrimitives[oldTransaction.UndoPrimitives.Count - 1];
return(newPrimitive.CanMerge(oldPrimitive));
}
return(false);
}
public UndoTransactionImpl(ITextUndoHistory history, ITextUndoTransaction parent, string description)
{
if (history == null)
{
throw new ArgumentNullException("history", String.Format(CultureInfo.CurrentUICulture, "Strings.ArgumentCannotBeNull", "UndoTransactionImpl", "history"));
}
if (String.IsNullOrEmpty(description))
{
throw new ArgumentNullException("description", String.Format(CultureInfo.CurrentUICulture, "Strings.ArgumentCannotBeNull", "UndoTransactionImpl", "description"));
}
this.history = history as UndoHistoryImpl;
if (this.history == null)
{
throw new ArgumentException("Strings.InvalidHistoryInTransaction");
}
this.parent = parent as UndoTransactionImpl;
if (this.parent == null && parent != null)
{
throw new ArgumentException("Strings.InvalidParentInTransaction");
}
this.description = description;
this.state = UndoTransactionState.Open;
this.primitives = new List <ITextUndoPrimitive>();
this.mergePolicy = NullMergeUndoTransactionPolicy.Instance;
this.IsReadOnly = true;
}
/// <summary>
/// Performs requested amount of redo operation and places the transactions on the undo stack.
/// UNDONE: What if there is a currently opened transaction?
/// </summary>
/// <param name="count">The number of redo operations to perform. At the end of the operation, requested number of visible
/// transactions are redone. Hence actual number of transactions redone might be more than this number if there are some
/// hidden transactions adjacent to (on top of or at the bottom of) the visible ones.
/// </param>
/// <remarks>
/// After the last visible transaction is redone, hidden transactions left on top the stack are redone as well until a
/// visible or linked transaction is encountered or stack is emptied totally.
/// </remarks>
public void Redo(int count)
{
if (count <= 0)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, "Strings.RedoAndUndoAcceptOnlyPositiveCounts", "Redo", count), "count");
}
if (!IsThereEnoughVisibleTransactions(this.redoStack, count))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, "Strings.CannotUndoMoreTransactionsThanExist", "redo", count));
}
TextUndoHistoryState originalState = this.state;
this.state = TextUndoHistoryState.Redoing;
using (new AutoEnclose(delegate { this.state = originalState; }))
{
while (count > 0)
{
if (!this.redoStack.Peek().CanRedo)
{
throw new InvalidOperationException("Strings.CannotRedoRequestedPrimitiveFromHistoryRedo");
}
ITextUndoTransaction ut = this.redoStack.Pop();
ut.Do();
this.undoStack.Push(ut);
RaiseUndoRedoHappened(this.state, ut);
--count;
}
}
}
/// <summary>
/// Performs requested amount of redo operation and places the transactions on the undo stack.
/// UNDONE: What if there is a currently opened transaction?
/// </summary>
/// <param name="count">The number of redo operations to perform. At the end of the operation, requested number of visible
/// transactions are redone. Hence actual number of transactions redone might be more than this number if there are some
/// hidden transactions adjacent to (on top of or at the bottom of) the visible ones.
/// </param>
/// <remarks>
/// After the last visible transaction is redone, hidden transactions left on top the stack are redone as well until a
/// visible or linked transaction is encountered or stack is emptied totally.
/// </remarks>
public void Redo(int count)
{
if (count <= 0)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if (!IsThereEnoughVisibleTransactions(this.redoStack, count))
{
throw new InvalidOperationException("Cannot redo more transactions than exist");
}
TextUndoHistoryState originalState = this.state;
this.state = TextUndoHistoryState.Redoing;
using (new AutoEnclose(delegate { this.state = originalState; }))
{
while (count > 0)
{
if (!this.redoStack.Peek().CanRedo)
{
throw new InvalidOperationException("Strings.CannotRedoRequestedPrimitiveFromHistoryRedo");
}
ITextUndoTransaction ut = this.redoStack.Pop();
ut.Do();
this.undoStack.Push(ut);
RaiseUndoRedoHappened(this.state, ut);
--count;
}
}
}
/// <summary>
/// Performs requested amount of redo operation and places the transactions on the undo stack.
/// UNDONE: What if there is a currently opened transaction?
/// </summary>
/// <param name="count">The number of redo operations to perform. At the end of the operation, requested number of visible
/// transactions are redone. Hence actual number of transactions redone might be more than this number if there are some
/// hidden transactions adjacent to (on top of or at the bottom of) the visible ones.
/// </param>
/// <remarks>
/// After the last visible transaction is redone, hidden transactions left on top the stack are redone as well until a
/// visible or linked transaction is encountered or stack is emptied totally.
/// </remarks>
public void Redo(int count)
{
if (count <= 0)
{
throw new ArgumentException("count must be > 0", nameof(count));
}
if (!IsThereEnoughVisibleTransactions(_redoStack, count))
{
throw new InvalidOperationException("No more undos/redos on the stack");
}
TextUndoHistoryState originalState = _state;
_state = TextUndoHistoryState.Redoing;
using (new AutoEnclose(delegate { this._state = originalState; })) {
while (count > 0)
{
if (!_redoStack.Peek().CanRedo)
{
throw new InvalidOperationException("Cannot redo/ask primitive from stack");
}
ITextUndoTransaction ut = _redoStack.Pop();
ut.Do();
_undoStack.Push(ut);
RaiseUndoRedoHappened(_state, ut);
--count;
}
}
}
/// <remarks>
/// Edits are queued up by our TextBufferChanged handler and then we finally add them to the
/// undo stack here in response to PostChanged. The reason and history behind why we do this
/// is as follows:
///
/// Originally this was done for VB commit, which uses undo events (i.e. TransactionCompleted) to
/// trigger commit. Their commit logic relies on the buffer being in a state such that applying
/// an edit synchronously raises a Changed event (which is always the case for PostChanged, but
/// not for Changed if there are nested edits).
///
/// JaredPar made a change (CS 1182244) that allowed VB to detect that UndoTransactionCompleted
/// was being fired from a nested edit, and therefore delay the actual commit until the following
/// PostChanged event.
///
/// So this allowed us to move TextBufferUndoManager back to adding undo actions directly
/// from the TextBufferChanged handler (CS 1285117). This is preferable, as otherwise there's a
/// "delay" between when the edit happens and when we record the edit on the undo stack,
/// allowing other people to stick something on the undo stack (i.e. from
/// their ITextBuffer.Changed handler) in between. The result is actions being "out-of-order"
/// on the undo stack.
///
/// Unfortunately, it turns out VB snippets actually rely on this "out-of-order" behavior
/// (see Dev10 834740) and so we are forced to revert CS 1285117) and return to the model
/// where we queue up edits and delay adding them to the undo stack until PostChanged.
///
/// It would be good to revisit this at again, but we would need to work with VB
/// to fix their snippets / undo behavior, and verify that VB commit is also unaffected.
/// </remarks>
private void TextBufferPostChanged(object sender, EventArgs e)
{
// Only process a top level PostChanged event. Nested events will continue to process TextChange events
// which are added to the queue and will be processed below
if (_inPostChanged)
{
return;
}
_inPostChanged = true;
try
{
// Do not do a foreach loop here. It's perfectly possible, and in fact expected, that the Complete
// method below can trigger a series of events which leads to a nested edit and another
// ITextBuffer::Changed. That event will add to the _editVersionList queue and hence break a
// foreach loop
while (_editVersionList.Count > 0)
{
var cur = _editVersionList.Dequeue();
using (ITextUndoTransaction undoTransaction = _undoHistory.CreateTransaction(Strings.TextBufferChanged))
{
TextBufferChangeUndoPrimitive undoPrimitive = new TextBufferChangeUndoPrimitive(_undoHistory, cur);
undoTransaction.AddUndo(undoPrimitive);
undoTransaction.Complete();
}
}
}
finally
{
_editVersionList.Clear(); // Ensure we cleanup state in the face of an exception
_inPostChanged = false;
}
}
public void PerformTransactionMerge(ITextUndoTransaction existingTransaction, ITextUndoTransaction newTransaction)
{
// Add all of our commit primitives into the existing transaction
foreach (var primitive in newTransaction.UndoPrimitives)
{
existingTransaction.UndoPrimitives.Add(primitive);
}
}
public void PerformTransactionMerge(ITextUndoTransaction existingTransaction, ITextUndoTransaction newTransaction)
{
// Add all of our commit primitives into the existing transaction
foreach (var primitive in newTransaction.UndoPrimitives)
{
existingTransaction.UndoPrimitives.Add(primitive);
}
}
private void RaiseUndoRedoHappened(TextUndoHistoryState state, ITextUndoTransaction transaction)
{
EventHandler <TextUndoRedoEventArgs> undoRedoHappened = UndoRedoHappened;
if (undoRedoHappened != null)
{
undoRedoHappened(this, new TextUndoRedoEventArgs(state, transaction));
}
}
public TextUndoTransaction(TextUndoHistory history, ITextUndoTransaction parent, string description)
{
this.history = history ?? throw new ArgumentNullException(nameof(history));
Parent = parent;
undoPrimitives = new List <ITextUndoPrimitive>();
readOnlyUndoPrimitives = new ReadOnlyCollection <ITextUndoPrimitive>(undoPrimitives);
State = UndoTransactionState.Open;
this.description = description ?? throw new ArgumentNullException(nameof(description));
}
private void RaiseUndoTransactionCompleted(ITextUndoTransaction transaction, TextUndoTransactionCompletionResult result)
{
EventHandler <TextUndoTransactionCompletedEventArgs> undoTransactionAdded = UndoTransactionCompleted;
if (undoTransactionAdded != null)
{
undoTransactionAdded(this, new TextUndoTransactionCompletedEventArgs(transaction, result));
}
}
public void PreOverType(out bool handledCommand)
{
handledCommand = false;
if (ClosingPoint == null)
{
return;
}
// Brace completion is not cancellable.
var cancellationToken = CancellationToken.None;
var snapshot = this.SubjectBuffer.CurrentSnapshot;
var document = snapshot.GetOpenDocumentInCurrentContextWithChanges();
SnapshotPoint closingSnapshotPoint = ClosingPoint.GetPoint(snapshot);
if (!HasForwardTyping && _session.AllowOverType(this, cancellationToken))
{
SnapshotPoint?caretPos = this.GetCaretPosition();
Debug.Assert(caretPos.HasValue && caretPos.Value.Position < closingSnapshotPoint.Position);
// ensure that we are within the session before clearing
if (caretPos.HasValue && caretPos.Value.Position < closingSnapshotPoint.Position && closingSnapshotPoint.Position > 0)
{
using (ITextUndoTransaction undo = CreateUndoTransaction())
{
_editorOperations.AddBeforeTextBufferChangePrimitive();
SnapshotSpan span = new SnapshotSpan(caretPos.Value, closingSnapshotPoint.Subtract(1));
using (ITextEdit edit = SubjectBuffer.CreateEdit())
{
edit.Delete(span);
if (edit.HasFailedChanges)
{
Debug.Fail("Unable to clear closing brace");
edit.Cancel();
undo.Cancel();
}
else
{
handledCommand = true;
edit.Apply();
MoveCaretToClosingPoint();
_editorOperations.AddAfterTextBufferChangePrimitive();
undo.Complete();
}
}
}
}
}
}
internal bool Begin(ITextUndoHistory undoHistory)
{
if (undoHistory != null)
{
_transaction = new HACK_TextUndoTransactionThatRollsBackProperly(undoHistory.CreateTransaction(Description));
return(true);
}
return(false);
}
private void EndTransaction()
{
if (_transaction != null)
{
_transaction.Dispose();
_transaction = null;
}
_active = false;
}
internal bool Begin(ITextUndoHistory undoHistory)
{
if (undoHistory != null)
{
_transaction = new HACK_TextUndoTransactionThatRollsBackProperly(undoHistory.CreateTransaction(Description));
return true;
}
return false;
}
public TextUndoTransaction(TextUndoHistory history, ITextUndoTransaction parent, string description) {
if (history == null)
throw new ArgumentNullException(nameof(history));
if (description == null)
throw new ArgumentNullException(nameof(description));
this.history = history;
Parent = parent;
undoPrimitives = new List<ITextUndoPrimitive>();
readOnlyUndoPrimitives = new ReadOnlyCollection<ITextUndoPrimitive>(undoPrimitives);
State = UndoTransactionState.Open;
this.description = description;
}
public SelectionUndo(ISelectionTracker selectionTracker, ITextBufferUndoManagerProvider undoManagerProvider, string transactionName, bool automaticTracking)
{
_selectionTracker = selectionTracker;
var undoManager = undoManagerProvider.GetTextBufferUndoManager(selectionTracker.TextView.TextBuffer);
ITextUndoTransaction innerTransaction = undoManager.TextBufferUndoHistory.CreateTransaction(transactionName);
_transaction = new TextUndoTransactionThatRollsBackProperly(innerTransaction);
_transaction.AddUndo(new StartSelectionTrackingUndoUnit(selectionTracker));
_selectionTracker.StartTracking(automaticTracking);
}
public MockTextUndoTransaction(ITextUndoHistory history, ITextUndoTransaction parent, string description)
{
_history = history as MockTextUndoHistory;
_parent = parent as MockTextUndoTransaction;
Description = description;
_state = UndoTransactionState.Open;
_primitives = new List<ITextUndoPrimitive>();
MergePolicy = NullMergeUndoTransactionPolicy.Instance;
IsReadOnly = true;
}
public ITextUndoTransaction CreateTransaction(string description)
{
if (_currentTransaction != null)
{
return new TextUndoTransaction(this, _currentTransaction);
}
else
{
_currentTransaction = new TextUndoTransaction(this);
return _currentTransaction;
}
}
public MassiveChange(ITextView textView, ITextBuffer textBuffer, ICompositionCatalog catalog, string description) {
_textBuffer = textBuffer;
var undoManagerProvider = catalog.ExportProvider.GetExportedValue<ITextBufferUndoManagerProvider>();
var undoManager = undoManagerProvider.GetTextBufferUndoManager(textView.TextBuffer);
ITextUndoTransaction innerTransaction = undoManager.TextBufferUndoHistory.CreateTransaction(description);
_transaction = new TextUndoTransactionThatRollsBackProperly(innerTransaction);
_transaction.AddUndo(new StartMassiveChangeUndoUnit(_textBuffer));
IREditorDocument document = REditorDocument.TryFromTextBuffer(_textBuffer);
document?.BeginMassiveChange();
}
bool ExecuteCommandCore(EditorCommandArgs args, CommandExecutionContext context, Operation operation)
{
ITextView textView = args.TextView;
ITextBuffer textBuffer = args.SubjectBuffer;
if (!XmlBackgroundParser.TryGetParser(textBuffer, out var parser))
{
return(false);
}
var xmlParseResult = parser.GetOrProcessAsync(textBuffer.CurrentSnapshot, default).Result;
var xmlDocumentSyntax = xmlParseResult.XDocument;
if (xmlDocumentSyntax == null)
{
return(false);
}
string description = operation.ToString();
var editorOperations = editorOperationsFactoryService.GetEditorOperations(textView);
var multiSelectionBroker = textView.GetMultiSelectionBroker();
var selectedSpans = multiSelectionBroker.AllSelections.Select(selection => selection.Extent);
using (context.OperationContext.AddScope(allowCancellation: false, description: description)) {
ITextUndoHistory undoHistory = undoHistoryRegistry.RegisterHistory(textBuffer);
using (ITextUndoTransaction undoTransaction = undoHistory.CreateTransaction(description)) {
switch (operation)
{
case Operation.Comment:
CommentSelection(textBuffer, selectedSpans, xmlDocumentSyntax, editorOperations, multiSelectionBroker);
break;
case Operation.Uncomment:
UncommentSelection(textBuffer, selectedSpans, xmlDocumentSyntax);
break;
case Operation.Toggle:
ToggleCommentSelection(textBuffer, selectedSpans, xmlDocumentSyntax, editorOperations, multiSelectionBroker);
break;
}
undoTransaction.Complete();
}
}
return(true);
}
/// <summary>
/// Commits all modifications made with specified <see cref="ITextBufferEdit"/> and link the commit
/// with <see cref="ITextUndoTransaction"/> in the Editor, if <see cref="_undoHistory"/> is available.
/// </summary>
/// <param name="edit">A set of editing operations on an <see cref="ITextBuffer"/>.</param>
/// <param name="description">The description of the transaction.</param>
private void ApplyEdit(ITextBufferEdit edit, string description)
{
if (_undoHistory != null)
{
using (ITextUndoTransaction transaction = _undoHistory.CreateTransaction(description))
{
edit.Apply();
transaction.Complete();
}
}
else
{
edit.Apply();
}
}
public void PreOverType(out bool handledCommand)
{
handledCommand = false;
// AllowOverType may make changes to the buffer such as for completing intellisense
if (!HasForwardTyping && (_context == null || _context.AllowOverType(this)))
{
SnapshotPoint?caretPos = CaretPosition;
SnapshotPoint closingSnapshotPoint = _closingPoint.GetPoint(SubjectBuffer.CurrentSnapshot);
Debug.Assert(caretPos.HasValue && caretPos.Value.Position < closingSnapshotPoint.Position);
// ensure that we are within the session before clearing
if (caretPos.HasValue && caretPos.Value.Position < closingSnapshotPoint.Position && closingSnapshotPoint.Position > 0)
{
using (ITextUndoTransaction undo = CreateUndoTransaction())
{
_editorOperations.AddBeforeTextBufferChangePrimitive();
SnapshotSpan span = new SnapshotSpan(caretPos.Value, closingSnapshotPoint.Subtract(1));
using (ITextEdit edit = _subjectBuffer.CreateEdit())
{
edit.Delete(span);
if (edit.HasFailedChanges)
{
Debug.Fail("Unable to clear closing brace");
edit.Cancel();
undo.Cancel();
}
else
{
handledCommand = true;
edit.Apply();
MoveCaretToClosingPoint();
_editorOperations.AddAfterTextBufferChangePrimitive();
undo.Complete();
}
}
}
}
}
}
public SelectionUndo(ISelectionTracker selectionTracker, string transactionName, bool automaticTracking)
{
if (!EditorShell.Current.IsUnitTestEnvironment)
{
_selectionTracker = selectionTracker;
var undoManagerProvider = EditorShell.Current.ExportProvider.GetExport <ITextBufferUndoManagerProvider>().Value;
var undoManager = undoManagerProvider.GetTextBufferUndoManager(selectionTracker.TextView.TextBuffer);
ITextUndoTransaction innerTransaction = undoManager.TextBufferUndoHistory.CreateTransaction(transactionName);
_transaction = new TextUndoTransactionThatRollsBackProperly(innerTransaction);
_transaction.AddUndo(new StartSelectionTrackingUndoUnit(selectionTracker));
_selectionTracker.StartTracking(automaticTracking);
}
}
public void Open(string name) {
Debug.Assert(_undoTransaction == null);
if (_undoTransaction == null && _undoManager != null && _editorOperations != null) {
_undoTransaction = _undoManager.TextBufferUndoHistory.CreateTransaction(name);
if (_addRollbackOnCancel) {
// Some hosts (*cough* VS *cough*) don't properly implement ITextUndoTransaction such
// that their Cancel operation doesn't rollback the already performed actions.
// In those scenarios, we'll use our own rollback mechanism (unabashedly copied
// from Roslyn)
_undoTransaction = new TextUndoTransactionThatRollsBackProperly(_undoTransaction);
}
_editorOperations.AddBeforeTextBufferChangePrimitive();
}
}
public CaretPreservingEditTransaction(
string description,
ITextView textView,
ITextUndoHistoryRegistry undoHistoryRegistry,
IEditorOperationsFactoryService editorOperationsFactoryService)
{
_editorOperations = editorOperationsFactoryService.GetEditorOperations(textView);
_undoHistory = undoHistoryRegistry.GetHistory(textView.TextBuffer);
_active = true;
if (_undoHistory != null)
{
_transaction = new HACK_TextUndoTransactionThatRollsBackProperly(_undoHistory.CreateTransaction(description));
_editorOperations.AddBeforeTextBufferChangePrimitive();
}
}
public CaretPreservingEditTransaction(
string description,
ITextView textView,
ITextUndoHistoryRegistry undoHistoryRegistry,
IEditorOperationsFactoryService editorOperationsFactoryService)
{
_editorOperations = editorOperationsFactoryService.GetEditorOperations(textView);
_undoHistory = undoHistoryRegistry.GetHistory(textView.TextBuffer);
_active = true;
if (_undoHistory != null)
{
_transaction = new HACK_TextUndoTransactionThatRollsBackProperly(_undoHistory.CreateTransaction(description));
_editorOperations.AddBeforeTextBufferChangePrimitive();
}
}
public MassiveChange(ITextView textView, ITextBuffer textBuffer, string description)
{
_textBuffer = textBuffer;
var undoManagerProvider = EditorShell.Current.ExportProvider.GetExport<ITextBufferUndoManagerProvider>().Value;
var undoManager = undoManagerProvider.GetTextBufferUndoManager(textView.TextBuffer);
ITextUndoTransaction innerTransaction = undoManager.TextBufferUndoHistory.CreateTransaction(description);
_transaction = new TextUndoTransactionThatRollsBackProperly(innerTransaction);
_transaction.AddUndo(new StartMassiveChangeUndoUnit(_textBuffer));
IREditorDocument document = REditorDocument.TryFromTextBuffer(_textBuffer);
if(document != null) {
document.BeginMassiveChange();
}
}
public void PerformTransactionMerge(ITextUndoTransaction existingTransaction, ITextUndoTransaction newTransaction)
{
if (existingTransaction == null)
throw new ArgumentNullException("existingTransaction");
if (newTransaction == null)
throw new ArgumentNullException("newTransaction");
// Remove trailing AfterTextBufferChangeUndoPrimitive from previous transaction and skip copying
// initial BeforeTextBufferChangeUndoPrimitive from newTransaction, as they are unnecessary.
int copyStartIndex = 0;
// Copy items from newTransaction into existingTransaction.
for (int i = copyStartIndex; i < newTransaction.UndoPrimitives.Count; i++)
{
existingTransaction.UndoPrimitives.Add(newTransaction.UndoPrimitives[i]);
}
}
public void PerformTransactionMerge(ITextUndoTransaction oldTransaction, ITextUndoTransaction newTransaction) {
MergeUndoActionPolicy oldPolicy = (MergeUndoActionPolicy)oldTransaction.MergePolicy;
MergeUndoActionPolicy newPolicy = (MergeUndoActionPolicy)newTransaction.MergePolicy;
// Remove trailing AfterTextBufferChangeUndoPrimitive from previous transaction and skip copying
// initial BeforeTextBufferChangeUndoPrimitive from newTransaction, as they are unnecessary.
if (oldTransaction.UndoPrimitives.Count > 0 && oldPolicy._addedTextChangePrimitives) {
oldTransaction.UndoPrimitives.RemoveAt(oldTransaction.UndoPrimitives.Count - 1);
}
int copyStartIndex = newPolicy._addedTextChangePrimitives ? 1 : 0;
for (int i = copyStartIndex; i < newTransaction.UndoPrimitives.Count; i++) {
oldTransaction.UndoPrimitives.Add(newTransaction.UndoPrimitives[i]);
}
}
private void FormatDocument()
{
using (ITextUndoTransaction transaction = _undoManager.TextBufferUndoHistory.CreateTransaction(Resources.Text.FormatDocument))
{
EditorConfigFormatter formatter = _view.Properties.GetOrCreateSingletonProperty(() => new EditorConfigFormatter(_view.TextBuffer));
bool changed = formatter.Format();
if (changed)
{
transaction.Complete();
}
else
{
transaction.Cancel();
}
}
}
public bool CanMerge(ITextUndoTransaction newTransaction, ITextUndoTransaction oldTransaction) {
MergeUndoActionPolicy oldPolicy = oldTransaction.MergePolicy as MergeUndoActionPolicy;
MergeUndoActionPolicy newPolicy = newTransaction.MergePolicy as MergeUndoActionPolicy;
if (oldPolicy != null && oldPolicy._mergeNext &&
newPolicy != null && newPolicy._mergePrevious &&
oldPolicy._actionName == newPolicy._actionName) {
// If one of the transactions is empty, than it is safe to merge
if (newTransaction.UndoPrimitives.Count == 0 ||
oldTransaction.UndoPrimitives.Count == 0) {
return true;
}
// Make sure that we only merge consecutive edits
ITextUndoPrimitive newPrimitive = newTransaction.UndoPrimitives[0];
ITextUndoPrimitive oldPrimitive = oldTransaction.UndoPrimitives[oldTransaction.UndoPrimitives.Count - 1];
return newPrimitive.CanMerge(oldPrimitive);
}
return false;
}
public HACK_TextUndoTransactionThatRollsBackProperly(ITextUndoTransaction innerTransaction)
{
_innerTransaction = innerTransaction;
_undoPrimitive = new RollbackDetectingUndoPrimitive();
}
private void RaiseUndoRedoHappened(TextUndoHistoryState state, ITextUndoTransaction transaction) {
EventHandler<TextUndoRedoEventArgs> undoRedoHappened = UndoRedoHappened;
undoRedoHappened?.Invoke(this, new TextUndoRedoEventArgs(state, transaction));
}
private void RaiseUndoTransactionCompleted(ITextUndoTransaction transaction, TextUndoTransactionCompletionResult result) {
EventHandler<TextUndoTransactionCompletedEventArgs> undoTransactionAdded = UndoTransactionCompleted;
undoTransactionAdded?.Invoke(this, new TextUndoTransactionCompletedEventArgs(transaction, result));
}
public void PerformTransactionMerge(ITextUndoTransaction existingTransaction, ITextUndoTransaction newTransaction) {
throw new InvalidOperationException("Strings.NullMergePolicyCannotMerge");
}
public bool CanMerge(ITextUndoTransaction newerTransaction, ITextUndoTransaction olderTransaction) {
return false;
}
public bool CanMerge(ITextUndoTransaction newerTransaction, ITextUndoTransaction olderTransaction)
{
// We want to merge with any other transaction of our policy type
return true;
}
public void PerformTransactionMerge(ITextUndoTransaction existingTransaction, ITextUndoTransaction newTransaction)
{
throw new NotImplementedException();
}
public bool ValidTransactionForMarkers(ITextUndoTransaction transaction) {
return transaction == null //// you can put a marker on the null transaction
|| _currentTransaction == transaction //// you can put a marker on the currently active transaction
|| (transaction.History == this && transaction.State != UndoTransactionState.Invalid);
//// and you can put a marker on any transaction in this history.
}
public ITextUndoTransaction CreateTransaction(string description)
{
_currentTransaction = new TextUndoTransaction(this);
return _currentTransaction;
}
private void EndTransaction()
{
if (_transaction != null)
{
_transaction.Dispose();
_transaction = null;
}
_active = false;
}
/// <summary>
/// This is how the transactions alert their containing history that they have finished
/// (likely from the Dispose() method).
/// </summary>
/// <param name="transaction">This is the transaction that's finishing. It should match the history's current transaction.
/// If it does not match, then the current transaction will be discarded and an exception will be thrown.</param>
public void EndTransaction(ITextUndoTransaction transaction) {
if (_currentTransaction != transaction) {
_currentTransaction = null;
throw new InvalidOperationException("Strings.EndTransactionOutOfOrder");
}
// only add completed transactions to their parents (or the stack)
if (_currentTransaction.State == UndoTransactionState.Completed) {
if (_currentTransaction.Parent == null) // stack bottomed out!
{
MergeOrPushToUndoStack(_currentTransaction);
}
}
_currentTransaction = _currentTransaction.Parent as UndoTransactionImpl;
}
public InteractiveGlobalUndoTransaction(ITextUndoTransaction transaction)
{
_transaction = transaction;
}