public void Undo(int count) { if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count)); } if (!(currentTransaction is null)) { throw new InvalidOperationException(); } if (State != TextUndoHistoryState.Idle) { throw new InvalidOperationException(); } if (count > undoList.Count) { throw new ArgumentOutOfRangeException(nameof(count)); } State = TextUndoHistoryState.Undoing; for (int i = 0; i < count; i++) { var transaction = undoList[undoList.Count - 1]; undoList.RemoveAt(undoList.Count - 1); redoList.Add(transaction); transaction.Undo(); UndoRedoHappened?.Invoke(this, new TextUndoRedoEventArgs(TextUndoHistoryState.Undoing, transaction)); } State = TextUndoHistoryState.Idle; }
/// <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; } } }
/// <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; } } }
internal void Undo(int count) { try { count = Math.Min(_undoStack.Count, count); _state = TextUndoHistoryState.Undoing; for (var i = 0; i < count; i++) { var current = _undoStack.Peek(); if (!current.CanUndo) { throw new InvalidOperationException(); } _undoStack.Pop(); current.Undo(); _redoStack.Push(current); RaiseUndoRedoHappened(); } } finally { _state = TextUndoHistoryState.Idle; } }
public UndoHistoryImpl(UndoHistoryRegistryImpl undoHistoryRegistry) { _currentTransaction = null; UndoHistoryRegistry = undoHistoryRegistry; _undoStack = new Stack<ITextUndoTransaction>(); _redoStack = new Stack<ITextUndoTransaction>(); _activeUndoOperationPrimitive = null; _state = TextUndoHistoryState.Idle; }
private void RaiseUndoRedoHappened(TextUndoHistoryState state, ITextUndoTransaction transaction) { EventHandler <TextUndoRedoEventArgs> undoRedoHappened = UndoRedoHappened; if (undoRedoHappened != null) { undoRedoHappened(this, new TextUndoRedoEventArgs(state, transaction)); } }
public UndoHistoryImpl(UndoHistoryRegistryImpl undoHistoryRegistry) { this.currentTransaction = null; this.UndoHistoryRegistry = undoHistoryRegistry; this.undoStack = new Stack <ITextUndoTransaction>(); this.redoStack = new Stack <ITextUndoTransaction>(); this.activeUndoOperationPrimitive = null; this.state = TextUndoHistoryState.Idle; }
public MockTextUndoHistory(MockTextUndoHistoryRegistry undoHistoryRegistry) { _currentTransaction = null; UndoHistoryRegistry = undoHistoryRegistry; _undoStack = new Stack <ITextUndoTransaction>(); _redoStack = new Stack <ITextUndoTransaction>(); _activeUndoOperationPrimitive = null; _state = TextUndoHistoryState.Idle; }
public TextUndoHistory(IPropertyOwner propertyOwner) { State = TextUndoHistoryState.Idle; PropertyOwner = propertyOwner ?? throw new ArgumentNullException(nameof(propertyOwner)); Properties = new PropertyCollection(); redoList = new List <TextUndoTransaction>(); undoList = new List <TextUndoTransaction>(); readOnlyRedoList = new ReadOnlyCollection <TextUndoTransaction>(redoList); readOnlyUndoList = new ReadOnlyCollection <TextUndoTransaction>(undoList); }
public TextUndoHistory(IPropertyOwner propertyOwner) { if (propertyOwner == null) throw new ArgumentNullException(nameof(propertyOwner)); State = TextUndoHistoryState.Idle; PropertyOwner = propertyOwner; Properties = new PropertyCollection(); redoList = new List<TextUndoTransaction>(); undoList = new List<TextUndoTransaction>(); readOnlyRedoList = new ReadOnlyCollection<TextUndoTransaction>(redoList); readOnlyUndoList = new ReadOnlyCollection<TextUndoTransaction>(undoList); }
internal void Undo(int count) { try { count = Math.Min(_undoStack.Count, count); _state = TextUndoHistoryState.Undoing; for (var i = 0; i < count; i++) { var current = _undoStack.Peek(); current.Undo(); _undoStack.Pop(); _redoStack.Push(current); } RaiseUndoRedoHappened(); } finally { _state = TextUndoHistoryState.Idle; } }
public void Redo(int count) { try { _state = TextUndoHistoryState.Redoing; for (var i = 0; i < count; i++) { var current = _redoStack.Peek(); current.Do(); _redoStack.Pop(); _undoStack.Push(current); } RaiseUndoRedoHappened(); } finally { _state = TextUndoHistoryState.Idle; } }
/// <summary> /// Performs a redo operation and places the primitives on the redo stack, up until (and /// including) the transaction indicated. This is called by the linked undo transaction that /// is aware of the linking relationship between transactions, and it does not call back into /// the transactions' public Redo(). /// </summary> /// <param name="transaction"></param> public void RedoInIsolation(MockTextUndoTransaction transaction) { TextUndoHistoryState originalState = _state; _state = TextUndoHistoryState.Redoing; using (new AutoEnclose(delegate { this._state = originalState; })) { if (_redoStack.Contains(transaction)) { MockTextUndoTransaction redone = null; while (redone != transaction) { MockTextUndoTransaction ut = _redoStack.Pop() as MockTextUndoTransaction; ut.Do(); _undoStack.Push(ut); RaiseUndoRedoHappened(_state, ut); redone = ut; } } } }
/// <summary> /// Performs an undo operation and places the primitives on the redo stack, up until (and /// including) the transaction indicated. This is called by the linked undo transaction that /// is aware of the linking relationship between transactions, and it does not call back into /// the transactions' public Undo(). /// </summary> /// <param name="transaction"></param> public void UndoInIsolation(UndoTransactionImpl transaction) { TextUndoHistoryState originalState = _state; _state = TextUndoHistoryState.Undoing; using (new AutoEnclose(delegate { this._state = originalState; })) { if (_undoStack.Contains(transaction)) { UndoTransactionImpl undone = null; while (undone != transaction) { UndoTransactionImpl ut = _undoStack.Pop() as UndoTransactionImpl; ut.Undo(); _redoStack.Push(ut); RaiseUndoRedoHappened(_state, ut); undone = ut; } } } }
/// <summary> /// Performs a redo operation and places the primitives on the redo stack, up until (and /// including) the transaction indicated. This is called by the linked undo transaction that /// is aware of the linking relationship between transactions, and it does not call back into /// the transactions' public Redo(). /// </summary> /// <param name="transaction"></param> public void RedoInIsolation(UndoTransactionImpl transaction) { TextUndoHistoryState originalState = this.state; this.state = TextUndoHistoryState.Redoing; using (new AutoEnclose(delegate { this.state = originalState; })) { if (this.redoStack.Contains(transaction)) { UndoTransactionImpl redone = null; while (redone != transaction) { UndoTransactionImpl ut = this.redoStack.Pop() as UndoTransactionImpl; ut.Do(); this.undoStack.Push(ut); RaiseUndoRedoHappened(this.state, ut); redone = ut; } } } }
/// <summary> /// Initializes a new instance of <see cref="TextUndoRedoEventArgs"/>. /// </summary> /// <param name="state">The <see cref="TextUndoHistoryState"/>.</param> /// <param name="transaction">The <see cref="ITextUndoTransaction"/>.</param> public TextUndoRedoEventArgs(TextUndoHistoryState state, ITextUndoTransaction transaction) { this.state = state; this.transaction = transaction; }
private void RaiseUndoRedoHappened(TextUndoHistoryState state, ITextUndoTransaction transaction) { EventHandler<TextUndoRedoEventArgs> undoRedoHappened = UndoRedoHappened; undoRedoHappened?.Invoke(this, new TextUndoRedoEventArgs(state, transaction)); }
/// <summary> /// Performs a redo operation and places the primitives on the redo stack, up until (and /// including) the transaction indicated. This is called by the linked undo transaction that /// is aware of the linking relationship between transactions, and it does not call back into /// the transactions' public Redo(). /// </summary> /// <param name="transaction"></param> public void RedoInIsolation(UndoTransactionImpl transaction) { TextUndoHistoryState originalState = _state; _state = TextUndoHistoryState.Redoing; using (new AutoEnclose(delegate { this._state = originalState; })) { if (_redoStack.Contains(transaction)) { UndoTransactionImpl redone = null; while (redone != transaction) { UndoTransactionImpl ut = _redoStack.Pop() as UndoTransactionImpl; ut.Do(); _undoStack.Push(ut); RaiseUndoRedoHappened(_state, ut); redone = ut; } } } }
public void Redo(int count) { if (count < 0) throw new ArgumentOutOfRangeException(nameof(count)); if (currentTransaction != null) throw new InvalidOperationException(); if (State != TextUndoHistoryState.Idle) throw new InvalidOperationException(); if (count > redoList.Count) throw new ArgumentOutOfRangeException(nameof(count)); State = TextUndoHistoryState.Redoing; for (int i = 0; i < count; i++) { var transaction = redoList[redoList.Count - 1]; redoList.RemoveAt(redoList.Count - 1); undoList.Add(transaction); transaction.Do(); UndoRedoHappened?.Invoke(this, new TextUndoRedoEventArgs(TextUndoHistoryState.Redoing, transaction)); } State = TextUndoHistoryState.Idle; }
internal void Redo(int count) { try { count = Math.Min(_redoStack.Count, count); _state = TextUndoHistoryState.Redoing; for (var i = 0; i < count; i++) { var current = _redoStack.Peek(); current.Do(); _redoStack.Pop(); _undoStack.Push(current); } RaiseUndoRedoHappened(); } finally { _state = TextUndoHistoryState.Idle; } }
public void Undo(int count) { try { _state = TextUndoHistoryState.Undoing; for (var i = 0; i < count; i++) { var current = _undoStack.Peek(); current.Undo(); _undoStack.Pop(); _redoStack.Push(current); } RaiseUndoRedoHappened(); } finally { _state = TextUndoHistoryState.Idle; } }
/// <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; } } }