private void Did(IUndoRedo iur) { try { m_UndoStack.Push(iur); m_RedoStack.Clear(); } catch (System.Exception ex) { DebugUtility.ShowExceptionMessageBox("添加撤销操作失败", ex); } DoSomething(this, new DoSomethingEventArgs(DoEventType.Did, iur.GetDoType())); // 暂时不处理 Stack超出上限 //if (m_UndoStack.Count >= GlobalData.UNDO_MAX_COUNT) //{ // Stack<IUndoRedo> undoCopyStack = new Stack<IUndoRedo>(); // for(int undoIdx = 0; undoIdx < GlobalData.UNDO_SAVE_COUNT; undoIdx++) // { // undoCopyStack.Push(m_UndoStack.Pop()); // } // m_UndoStack.Clear(); // while(undoCopyStack.Count > 0) // { // m_UndoStack.Push(undoCopyStack.Pop()); // } //} }
bool IMergableOperation.TryMergeWith(IUndoRedo other, bool isBulkOperation) { if (!isBulkOperation) { return(false); } var otherTLV = other as AddTopLevelViewOperation; if (otherTLV != null) { this.relatedAdds.Add(otherTLV); return(true); } var setRoot = other as SetRootOperation; if (setRoot != null) { _rootChange = setRoot; return(true); } return(false); }
bool IMergableOperation.TryMergeWith(IUndoRedo other, bool isBulkOperation) { if (!isBulkOperation) { return(false); } var otherLFA = other as ArrayFieldAddOperation; if (otherLFA != null) { if (_relatedAdds == null) { _relatedAdds = new List <ArrayFieldAddOperation>(1); } _relatedAdds.Add(otherLFA); //There is no need for related adds to hold onto their references as they are not used otherLFA._arr = null; otherLFA._setter = null; return(true); } return(false); }
public void Add(IUndoRedo cmd) { if (_enableAdd) { _undoList.Add(cmd); _redoList.Clear(); } }
public void Redo(DataGridView dataGridView, DataTable dataTable) { for (int thingIdx = 0; thingIdx < ThingsList.Count; thingIdx++) { IUndoRedo thing = ThingsList[thingIdx]; thing.Redo(dataGridView, dataTable); } }
public void Undo(DataGridView dataGridView, DataTable dataTable) { for (int thingIdx = ThingsList.Count - 1; thingIdx >= 0; thingIdx--) { IUndoRedo thing = ThingsList[thingIdx]; thing.Undo(dataGridView, dataTable); } }
public DefaultCanvas() { //Console.WriteLine(colorPick); this.ObjectToDraw = new List <IDrawingObject>(); this.DoubleBuffered = true; this.Tool = null; this.undoRedo = new DefaultUndoRedo(this); }
public UndoMemento(IUndoRedo sender, ActionType actionType, string description) { if (sender == null || description == null) { throw new ArgumentNullException(); } m_Sender = sender; m_ActionType = actionType; m_Description = description; }
public static void DoRedoActions(IUndoRedo context, IUndoMemento memento) { if (memento.Sender == context) { foreach (var redoAction in memento.RedoActions) { redoAction(); } } }
public UndoMemento(IUndoRedo sender, ActionType actionType, string description) { if (sender == null || description == null) { throw new ArgumentNullException(); } m_Sender = sender; m_ActionType = actionType; m_Description = description; }
public void Redo() { if (this.oUndoRedoHandler is IUndoRedo) { IUndoRedo iur = (IUndoRedo)this.oUndoRedoHandler; iur.Redo(this.o, this.ura, this.oData); } else { throw new InterfaceNotImplementedException("IUndoRedo in " + this.oUndoRedoHandler.GetType().ToString() + " not implemented!"); } }
public void Undo() { if (!CanUndo()) { return; } IUndoRedo action = undoStack.Pop(); action.Undo(); redoStack.Push(action); NotifyPropertyChanged("UndoDescription"); NotifyPropertyChanged("RedoDescription"); UndoOrRedoCalled?.Invoke(this, new EventArgs()); }
public UndoMemento(IUndoRedo sender, ActionType actionType, string description, IEnumerable <Action> undoActions, IEnumerable <Action> redoActions) { if (sender == null || description == null || undoActions == null || redoActions == null) { throw new ArgumentNullException(); } m_Sender = sender; m_ActionType = actionType; m_Description = description; m_UndoActions = new List <Action>(undoActions); m_RedoActions = new List <Action>(redoActions); }
/// <summary> /// Redo the last undone action, if any. /// </summary> public bool Redo() { if (_redoStack.Count == 0) { return(false); } IUndoRedo action = _redoStack.Pop(); action.Redo(); _undoStack.Push(action); return(true); }
public UndoMemento(IUndoRedo sender, ActionType actionType, string description, IEnumerable<Action> undoActions, IEnumerable<Action> redoActions) { if (sender == null || description == null || undoActions == null || redoActions == null) { throw new ArgumentNullException(); } m_Sender = sender; m_ActionType = actionType; m_Description = description; m_UndoActions = new List<Action>(undoActions); m_RedoActions = new List<Action>(redoActions); }
public void Redo() { if (RedoList.Count > 0) { IUndoRedo item = RedoList.First(); RedoList.RemoveFirst(); LinkedList <IUndoRedo> cpyRedo = new LinkedList <IUndoRedo>(RedoList.ToList()); item.Redo(); RedoList = new LinkedList <IUndoRedo>(cpyRedo); RaisePropertyChanged("RedoDescription"); RaisePropertyChanged("UndoDescription"); } }
public void AddUndo(IUndoRedo undo) { if (Capacity == 0) { return; } if (redoStack.Count > 0) { redoStack.Clear(); } undoStack.Push(undo); NotifyPropertyChanged("UndoDescription"); NotifyPropertyChanged("RedoDescription"); }
bool IMergableOperation.TryMergeWith(IUndoRedo other, bool isBulkOperation) { var otherEFO = other as EditorFieldOperation <T>; if (otherEFO == null) { return(false); } if (object.ReferenceEquals(_owner, otherEFO._owner) && object.ReferenceEquals(_member, otherEFO._member)) { _newValue = otherEFO._newValue; return(true); } return(false); }
bool IMergableOperation.TryMergeWith(IUndoRedo other, bool isBulkOperation) { var otherVCO = other as ViewValueChangeOperation; if (otherVCO == null) { return(false); } if (object.ReferenceEquals(this.view, otherVCO.view) && (_target == otherVCO._target)) { _newValue = otherVCO._newValue; return(true); } return(false); }
bool IMergableOperation.TryMergeWith(IUndoRedo other, bool isBulkOperation) { if (!isBulkOperation) { return(false); } var otherTLV = other as RemoveTopLevelViewOperation; if (otherTLV != null) { this.relatedRemovals.Add(otherTLV); return(true); } return(false); }
internal void Register(IUndoRedo op) { if (_current.HasValue) { bool prune = (_head != _current.Value); if (_savePoint > _current.Value) { _validSavePoint = false; } _current = (_current + 1) % _array.Length; _head = _current.Value; if (prune) { if (_tail < _head) { Array.Clear(_array, 0, _tail); var top = _head + 1; if (top < _array.Length) { Array.Clear(_array, top, _array.Length - top); } } else if (_tail > _head) { Array.Clear(_array, _head + 1, _tail - _head - 1); } } else if (_tail == _head) { _tail++; } } else { Clear(); _current = _head = 0; } _array[_current.Value] = op; }
public void Redo() { if (CanRedo()) { try { m_CsvForm.BeforeChangeCellValue(); IUndoRedo iur = m_RedoStack.Pop(); iur.Redo(m_CsvForm.GetDataGridView(), m_CsvForm.GetDataTable()); m_UndoStack.Push(iur); DoSomething(this, new DoSomethingEventArgs(DoEventType.Redo, iur.GetDoType())); m_CsvForm.AfterChangeCellValue(); MainForm.Instance.UpdateCellEdit(); } catch (System.Exception ex) { DebugUtility.ShowExceptionMessageBox("重做失败", ex); } } }
bool IMergableOperation.TryMergeWith(IUndoRedo other, bool isBulkOperation) { if (!isBulkOperation) { return(false); } var otherLFA = other as ListFieldAddOperation; if (otherLFA != null) { if (_relatedAdds == null) { _relatedAdds = new List <ListFieldAddOperation>(1); } _relatedAdds.Add(otherLFA); return(true); } return(false); }
/// <summary> /// Register a new undo command along with an undo handler. /// The undo handler is used to perform the actual undo or redo operation later when requested. /// </summary> /// <param name = "cmd">New command to add to the manager.</param> /// <param name = "undoHandler">Undo handler to perform the actual undo/redo operation.</param> private void AddUndoCommand(IUndoRedo cmd, IUndoRedoHandler undoHandler) { if (cmd == null) { throw new NullReferenceException("The cmd sent to AddUndoCommand should not be null."); } if (this._maxUndoLevel == 0) { return; } if (this._undoList.Count == this._maxUndoLevel) { this._undoList.RemoveAt(0); } // Insert the new undoable command into the undo list. this._undoList.Add(new UndoRedoInfo(cmd, undoHandler)); // Clear the redo stack. this.ClearRedo(); }
internal void Do(IUndoRedo operation) { var viewBound = operation as IViewBoundOperation; if (viewBound != null) { viewBound.view = _ui.selectedView; } var last = (this.isBulkOperation ? _bulkOperation.lastOperation : _log.lastEntry) as IMergableOperation; if (last != null && last.TryMergeWith(operation, this.isBulkOperation)) { return; } if (this.isBulkOperation) { _bulkOperation.lastOperation = operation; } _log.Register(operation); _functionalChangeCount++; }
/// <summary> /// Register a new undo command. Use this method after your /// application has performed an operation/command that is undoable. /// </summary> /// <param name = "cmd">New command to add to the manager.</param> public void AddUndoCommand(IUndoRedo cmd) { this.AddUndoCommand(cmd, null); }
public UndoRedoInfo(IUndoRedo undoable, IUndoRedoHandler doHandler) { this.UndoRedoObject = undoable; this.UndoRedoHandler = doHandler; }
//Used for adding the Undo/Redo command to the "undoStack", clears the "redoStack", // and executes the command public void AddAndExecute(IUndoRedo command) { undoStack.Push(command); redoStack.Clear(); command.Execute(); drawingIsSaved = false; }
public void Dispose() { _parent.isBulkOperation = false; lastOperation = null; }
public void Add(IUndoRedo cmd) { _undoList.Add(cmd); _redoList.Clear(); }
public static void DoRedoActions(IUndoRedo context, IUndoMemento memento) { if (memento.Sender == context) { foreach (var redoAction in memento.RedoActions) { redoAction(); } } }
public override bool CanLogData(IUndoRedo source, object data) { return(base.CanLogData(source, data)); }
// make it easier to add a single undo to a collection right away public UndoRedoCollection(UndoRedoType type, IUndoRedo ur) { Type = type; Add(ur); }
public void Add(IUndoRedo ur) { undoRedos.Add(ur); }