private void OnTextBufferChanging(object sender, TextContentChangingEventArgs e)
{
var methodOccurence = _codeBlockOccurrences
.Where(occurence => occurence.Block.FullSpan.IntersectsWith(_view.Caret.Position.BufferPosition.Position))
.Select(occurence => occurence)
.FirstOrDefault();
string methodName = string.Empty;
int linesOfCode = 0;
GetMethodNameAndLineCount(methodOccurence.Block, out methodName, out linesOfCode);
var feedbacks = _feedbackMachine.RequestFeedbackBeforeMethodCodeChange(methodName, linesOfCode);
foreach (var feedback in feedbacks)
{
if (feedback is InsertTextFeedback)
{
InsertText(feedback);
}
else if (feedback is DelayKeyboardInputsFeedback)
{
DelayKeyboardInput(feedback);
}
else if (feedback is PreventKeyboardInputsFeedback)
{
e.Cancel();
}
}
}
private void Textbuffer_Changing(object sender, TextContentChangingEventArgs e)
{
if (XSettings.DebuggerIsRunning)
{
XSettings.ShowMessageBox("Cannot edit source code while debugging");
e.Cancel();
}
}
void TextBufferChanging(object sender, TextContentChangingEventArgs e)
{
// See if somebody (other than us) is trying to edit the buffer during undo/redo.
if (_undoHistory.State != TextUndoHistoryState.Idle &&
(e.EditTag as Type) != typeof(TextBufferChangeUndoPrimitive))
{
Debug.Fail("Attempt to edit the buffer during undo/redo has been denied. This is explicitly prohibited as it would corrupt the undo stack! Please fix your code.");
e.Cancel();
}
}
private void HandleTextChanging(object sender, TextContentChangingEventArgs e)
{
// If we are in multi-edit mode then look to see if the change is applied
// to the version we were expecting to edit - if not then we assume this
// is an auto-format change which we do not want
if (this.InMultiEditMode &&
this.expectedEditVersion != null &&
e.BeforeVersion != this.expectedEditVersion)
{
e.Cancel();
}
}
private void HandleTextBufferChanging(object sender, TextContentChangingEventArgs e)
{
//Prevent the text from changing while the margin is visible, since the text needs to be loaded when the
//margin is shown, and this keeps it consistent.
//The second disjunct makes sure that a conversation is currently happening. It also makes sure that edits are not tagged
//with the context manager. Edits made by the manager in response to a client sending edited code back should not be cancelled,
//and will be tagged with the manager. Edits made by the user directly have no tag and need to be cancelled while a conversation
//is happening to prevent the concurrent modification.
if (ViewSearchMargin.ActualWidth > 0 || (_manager != null && _manager.Started && e.EditTag != _manager))
{
e.Cancel();
}
}
void TextBufferChanging(object sender, TextContentChangingEventArgs e)
{
// Note that VB explicitly forces undo edits to happen while the history is idle so we need to allow this here
// by always doing nothing for undo edits). This may be a bug in our code (e.g. not properly cleaning up when
// an undo transaction is cancelled in mid-flight) but changing that will require coordination with Roslyn.
if (!(e.EditTag is IUndoEditTag))
{
if (this.TextBufferUndoHistory.State != TextUndoHistoryState.Idle)
{
Debug.Fail("We are doing a normal edit in a non-idle undo state. This is explicitly prohibited as it would corrupt the undo stack! Please fix your code.");
e.Cancel();
}
}
}