/// <summary>
/// Handles a command.
/// </summary>
/// <param name="sender">The object that originated the event.</param>
/// <param name="executedRoutedEventArgs">The event arguments.</param>
internal void OnCommand(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
// The undo command will pop a generic handler off the stack that will roll back the last operation.
if (executedRoutedEventArgs.Command == ApplicationCommands.Undo)
{
// This indicates that the command was handled and no further action is required.
executedRoutedEventArgs.Handled = true;
// Keep popping operations off the stack until the stack is exhausted. The 'undo' handler is specified by the specific control handlers when
// operation was pushed onto the stack. Each handler has the information needed to 'undo' the specific action that pushed this object onto the
// stack.
if (this.undoStackField.Count > 0)
{
CommandArgumentPair commandArgumentPair = this.undoStackField.Pop();
commandArgumentPair.GenericEventHandler(this, commandArgumentPair.GenericEventArgs);
}
}
// the redo command will pop a generic handler off the stack that will roll forward the last operation.
if (executedRoutedEventArgs.Command == ApplicationCommands.Redo)
{
// This indicates that the command was handled and no further action is required.
executedRoutedEventArgs.Handled = true;
// Keep popping operation off the stack until the stack is exhausted. The 'redo' handler is specified by the specific control handler when the
// the operation was pushed onto the stack.
if (this.redoStackField.Count > 0)
{
CommandArgumentPair commandArgumentPair = this.redoStackField.Pop();
commandArgumentPair.GenericEventHandler(this, commandArgumentPair.GenericEventArgs);
}
}
}
/// <summary>
/// Handles changes to the content of the RichTextBox family of controls.
/// </summary>
/// <param name="sender">The object that originated the event.</param>
/// <param name="e">The event arguments.</param>
public override void TextChangedHandler(Object sender, TextChangedEventArgs e)
{
// Validate the parameters.
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
// The RichTextBox generates its own series of state changes for handling the Undo/Redo logic. The main idea is to integrate the local operations into
// the UndoScope so that they all appear to be one long sequence of actions that are captured in the Undo/Redo stacks.
RichTextBox richTextBox = sender as RichTextBox;
if (richTextBox != null)
{
// Only user initiated operations will modify the Undo/Redo stacks.
switch (e.UndoAction)
{
case UndoAction.Redo:
// Undoing a 'Redo' is handled by undoing the operation again. This balances out the stack when doing
// multiple Undo/Redo commands.
this.UndoManager.UndoStack.Push(new CommandArgumentPair(this.Undo, richTextBox));
break;
case UndoAction.Undo:
// This allows the operation that was just 'undone' to be 'redone' by pushing it onto a stack. The a
// high-level 'Redo' command is handled by the root control in this scope, this command will be popped off
// the stack in the order it was 'Undone' and the original content will be restored.
this.UndoManager.RedoStack.Push(new CommandArgumentPair(this.Redo, richTextBox));
break;
case UndoAction.Merge:
// Merging is a way of combining serial changes to the text content. Typing a sequence of two or more
// characters doesn't need to push each character on the stack. This combines similar sequences of actions
// into a single action on the stack.
CommandArgumentPair commandArgumentPair = this.UndoManager.UndoStack.Peek();
RichTextBox currentRichTextBox = (RichTextBox)commandArgumentPair.GenericEventArgs.Arguments[0];
if (currentRichTextBox != richTextBox)
{
this.UndoManager.UndoStack.Push(new CommandArgumentPair(this.Undo, richTextBox));
}
break;
case UndoAction.Create:
// This action creates an action on the stack. Similar actions will be merged into this item on the stack
// and can be undone with a single call to 'Undo'.
this.UndoManager.UndoStack.Push(new CommandArgumentPair(this.Undo, richTextBox));
break;
}
}
}