public IUndoRedoAction Execute()
{
var ii = Collection as ISupportInitialize;
if (ii != null)
{
ii.BeginInit();
}
IUndoRedoAction result = null;
if (Args.Action == NotifyCollectionChangedAction.Add)
{
Collection.RemoveAt(Collection.Count - 1);
result = new CollectionChangeUndoRedoAction(Collection, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, Args.NewItems));
}
if (Args.Action == NotifyCollectionChangedAction.Remove)
{
foreach (var i in Args.OldItems)
{
Collection.Add(i);
}
result = new CollectionChangeUndoRedoAction(Collection, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, Args.OldItems));
}
if (ii != null)
{
ii.EndInit();
}
return(result);
}
private void OnUndoRedoEnd(IUndoRedoAction action)
{
if (action is PostObjectTransformsChangedAction)
{
RefreshPositionAndRotation();
}
}
private void OnUndoRedoEnd(IUndoRedoAction action)
{
if (action is PostObjectTransformsChangedAction)
{
FitBoxToTargetHierarchy();
}
}
public static IUndoRedoAction Pop(List <IUndoRedoAction> list)
{
IUndoRedoAction topAction = list[0];
list.RemoveAt(0);
return(topAction);
}
public void RecordAction(IUndoRedoAction action)
{
if (!_isEnabled)
{
return;
}
// We must handle a special scenario which can occur when the user has been undoing
// actions and effectively moving the stack pointer somewhere in the middle of the
// stack. In that case, when a new action is recorded, this action will invalidate
// all actions which follow.
if (_actionGroupStack.Count != 0 &&
_stackPointer < _actionGroupStack.Count - 1)
{
// Calculate the index of the first action to be removed and the number of actions to remove
// and then use these values to remove the correct range of actions from the stack.
int removeStartIndex = _stackPointer + 1;
int removeCount = _actionGroupStack.Count - removeStartIndex;
RemoveGroups(removeStartIndex, removeCount);
}
_actionGroupStack.Add(new ActionGroup(action));
// The last step is to check if the current number of recorded actions is bigger than the
// allowed maximum. If it is, we need to remove the action from the bottom of the stack.
// Finally, we set the stack pointer to point to the last recorded action.
if (_actionGroupStack.Count > _actionLimit)
{
RemoveGroups(0, 1);
}
_stackPointer = _actionGroupStack.Count - 1;
}
private void OnUndoRedoEnd(IUndoRedoAction action)
{
if (action is ObjectExtrudeGizmoDragEnd)
{
FitBoxToTargets();
}
}
public void AddUndoRedoAction(IUndoRedoAction action)
{
if (enableUndoRedo == 0)
{
if (isInApplyUndo)
{
Message.Show("Nested ApplyDoUndo calls! This is bad!", "Undo Redo borked", "Ok");
action.Do();
return;
}
isInApplyUndo = true;
action.Do();
RedoStack.Clear();
if (UndoStack.Count > 0)
{
var lastGroup = UndoStack.Peek();
var currentTime = DateTime.Now;
var diff = (currentTime - lastGroup.LastActionTime).TotalMilliseconds;
if (diff <= GroupingMS)
{
lastGroup.Actions.Add(action);
lastGroup.LastActionTime = currentTime;
}
else
{
var group = new UndoRedoGroup();
group.Actions.Add(action);
group.LastActionTime = currentTime;
UndoStack.Push(group);
}
}
else
{
var group = new UndoRedoGroup();
group.Actions.Add(action);
group.LastActionTime = DateTime.Now;
UndoStack.Push(group);
}
RaisePropertyChangedEvent("IsModified");
RaisePropertyChangedEvent("CanUndo");
RaisePropertyChangedEvent("CanRedo");
RaisePropertyChangedEvent("DescriptionStack");
isInApplyUndo = false;
}
else
{
action.Do();
}
}
/// <summary>
/// Adds action to Undo stack
/// </summary>
/// <param name="action">Action to track</param>
public static void TrackAction(IUndoRedoAction action)
{
if (UndoActions.Count >= Capacity)
{
UndoActions.RemoveFirst();
}
UndoActions.AddLast(action);
RedoActions.Clear();
}
/// <summary>
/// Registers an undo redo action.
/// </summary>
/// <param name="action">The action to register. Cannot be null.</param>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
public void RegisterExecutedAction(IUndoRedoAction action)
{
Guard.NotNull(action, nameof(action));
undoStack.Push(action);
redoStack.Clear();
OnStateChanged(StateChangedReason.Register, new List <IUndoRedoAction> {
action
});
}
/// <summary>
/// Undoes commands
/// </summary>
/// <param name="levels">number of commands to undo</param>
public static void Undo(int levels)
{
for (int i = 0; i < levels; i++)
{
if (UndoActions.Count != 0)
{
IUndoRedoAction command = UndoActions.Last.Value;
UndoActions.RemoveLast();
command.UnExecute();
if (RedoActions.Count >= Capacity)
{
RedoActions.RemoveFirst();
}
RedoActions.AddLast(command);
}
}
}
public void Add(IUndoRedoAction redoAction)
{
UndoStack.Push(redoAction);
RedoStack.Clear();
this.RaisePropertyChangedEvents();
}
public static void Push(List <IUndoRedoAction> list, IUndoRedoAction action)
{
list.Insert(0, action);
}
/// <summary>
/// Do the given action for the first time. This method will call the Do() method on he action.
/// </summary>
/// <param name="action">The action to do. The Do() method will be called</param>
public void Do(IUndoRedoAction action)
{
action.Do();
Done(action);
}
/// <summary>
/// Записывает действие в очередь на отмену
/// </summary>
public void PushAction(IUndoRedoAction action)
{
undoActions.Push(action);
FireChanged(action.Target);
}
/// <summary>
/// Do the given action for the first time. This method will call the Do() method on he action.
/// </summary>
/// <param name="action">The action to do. The Do() method will be called</param>
public void Do(IUndoRedoAction action)
{
action.Do();
undoStack.Push(action);
redoStack.Clear();
}
public void Done(IUndoRedoAction action)
{
undoStack.Push(action);
redoStack.Clear();
OnUndoRedoAction.Fire();
}
/// <summary>
/// Adds a action to the composite action.
/// </summary>
/// <param name="action">The action to add.</param>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
public void Add(IUndoRedoAction action)
{
Guard.NotNull(action, nameof(action));
actions.Add(action);
}
public ActionGroup(IUndoRedoAction action)
{
Actions.Add(action);
}
private void OnUndoRedo(IUndoRedoAction action)
{
OnTargetObjectGroupUpdated();
}
public void Add(IUndoRedoAction redoAction)
{
UndoStack.Push(redoAction);
RedoStack.Clear();
this.RaisePropertyChangedEvents();
}
public void AddUndoRedoOperation(IUndoRedoAction operation)
{
_undoRedoActions.Insert(0, operation);
}
