private void DrawOperationMgrUI()
{
if (EditorUtils.DrawHeader("操作管理", "TerrainEditor"))
{
limitStackCount = EditorGUILayout.IntSlider("栈数限制", limitStackCount, 5, 100);
if (GUILayout.Button("Undo" + "( " + (undoStack.Count > 0 ? undoStack.Peek().name : "无") + " )"))
{
if (undoStack.Count > 0)
{
isUndoTopPop = true;
UndoRedoOperation undoRedoOperation = undoStack.Pop();
redoStack.Push(undoRedoOperation);
undoRedoOperation = undoStack.Pop();
undoRedoOperation.DoIt();
redoStack.Push(undoRedoOperation);
}
}
if (GUILayout.Button("Redo" + "( " + (redoStack.Count > 0?redoStack.Peek().name:"无") + " )"))
{
if (redoStack.Count > 0)
{
UndoRedoOperation undoRedoOperation = redoStack.Pop();
undoStack.Push(undoRedoOperation);
undoRedoOperation = redoStack.Pop();
undoRedoOperation.DoIt();
undoStack.Push(undoRedoOperation);
}
}
}
}
void RaiseChanged(UndoRedoOperation undoRedo, string action)
{
if (Changed != null)
{
Changed(this, new UndoRedoEventArgs(undoRedo, action));
}
}
public void PushReverseAction <T>(UndoRedoOperation <T> undoOperation, T undoData)
{
List <IUndoRedoAction> stack = null;
if (_undoInProgress)
{
stack = _redoActions;
}
else
{
stack = _undoActions;
}
if ((!_undoInProgress) && (!_redoInProgress))
{
//_redoActions.Clear();
}
if (_curTran == null)
{
ListOperations.Push(stack, new UndoRedoAction <T>(undoOperation, undoData));
}
else
{
(stack[0] as UndoTransaction).AddUndoRedoOperation(new UndoRedoAction <T>(undoOperation, undoData));
}
if (stack.Count > _maximumActions)
{
stack.RemoveRange(_maximumActions - 1, stack.Count - _maximumActions);
}
}
/// <summary>
/// Pushes an item onto the undo/redo stack.
/// 1) If this is called outside the context of a undo/redo operation, the item is added to the undo stack.
/// 2) If this is called in the context of an undo operation, the item is added to redo stack.
/// 3) If this is called in context of an redo operation, item is added to undo stack.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="undoOperation"></param>
/// <param name="undoData"></param>
/// <param name="description"></param>
public void Push <T>(UndoRedoOperation <T> undoOperation, T undoData, string description = "")
{
Debug.Assert(null != undoOperation);
if (IsStopPush)
{
return;
}
List <IUndoRedoRecord> stack = null;
Action eventToFire;
///Determien the stack to which this operation will be added
if (_undoGoingOn)
{
Trace.TraceInformation("Adding to redo stack {0} with data {1}", undoOperation.Method.Name, undoData);
stack = _redoStack;
eventToFire = new Action(FireRedoStackStatusChanged);
}
else
{
Trace.TraceInformation("Adding to undo stack {0} with data {1}", undoOperation.Method.Name, undoData);
stack = _undoStack;
eventToFire = new Action(FireUndoStackStatusChanged);
}
if ((!_undoGoingOn) && (!_redoGoingOn))
{//if someone added an item to undo stack while there are items in redo stack.. clear the redo stack
_redoStack.Clear();
FireRedoStackStatusChanged();
}
///If a transaction is going on, add the operation as a entry to the transaction operation
if (!_hasTransaction)
{
stack.Push(new UndoRedoRecord <T>(undoOperation, undoData, description));
}
else
{
(stack[0] as UndoTransaction).AddUndoRedoOperation(new UndoRedoRecord <T>(undoOperation, undoData,
description));
}
//If the stack count exceeds maximum allowed items
if (stack.Count > MaxItems)
{
object o = stack[stack.Count - 1];
Trace.TraceInformation("Removing item {0}", o);
stack.RemoveRange(MaxItems - 1, stack.Count - MaxItems);
}
//Fire event to inform consumers that the stack size has changed
eventToFire();
}
/// <summary>
/// 向撤销/重做堆栈推入操作
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="undoOperation"></param>
/// <param name="undoData"></param>
/// <param name="description"></param>
public void Push <T>(UndoRedoOperation <T> undoOperation, T undoData, string description = "")
{
List <IUndoRedoRecord> stack;
Action eventToFire;
// 通过撤销/重做标识决定如何堆栈
if (_UndoGoingOn)
{
stack = _RedoStack;
eventToFire = FireRedoStackStatusChanged;
}
else
{
stack = _UndoStack;
eventToFire = FireUndoStackStatusChanged;
}
if (!_UndoGoingOn && !_RedoGoingOn)
{
_RedoStack.Clear();
FireRedoStackStatusChanged();
}
// 如果正在进行事务，则将该操作作为条目添加到事务操作中
if (_CurTran == null)
{
stack.Push(new UndoRedoRecord <T>(undoOperation, undoData, description));
}
else
{
((UndoTransaction)stack[0]).AddUndoRedoOperation(new UndoRedoRecord <T>(undoOperation, undoData,
description));
}
// 堆栈计数超过允许的最大项
if (stack.Count > MaxItems)
{
stack.RemoveRange(MaxItems - 1, stack.Count - MaxItems);
}
// 通知消费者堆栈大小已更改
eventToFire();
}
/// <summary>
/// Pushes the specified undo operation.
/// </summary>
/// <typeparam name="T">type of the first paramater of the operation to be performed</typeparam>
/// <typeparam name="K">type of the second paramater of the operation to be performed</typeparam>
/// <param name="undoOperation">The undo operation.</param>
/// <param name="undoData">The undo data.</param>
/// <param name="undoData1">The undo data1.</param>
/// <param name="description">The description.</param>
public void Push <T, K>(UndoRedoOperation <T, K> undoOperation, T undoData, K undoData1, string description = "")
{
Action eventToFire = this.GetEventToBeFired();
List <IUndoRedoRecord> stack = this.GetStackToAddTo();
this.ClearRedoStackIfAddedItemToUndo();
// If a transaction is going on, add the operation as a entry to the transaction operation
if (this.currentTransaction == null)
{
stack.Push(new UndoRedoRecord <T, K>(undoOperation, undoData, undoData1, description));
}
else
{
(stack[0] as UndoTransaction).AddUndoRedoOperation(new UndoRedoRecord <T, K>(undoOperation, undoData, undoData1, description));
}
this.TrimStackMaximumExceed(stack);
// Fire event to inform consumers that the stack size has changed
eventToFire();
}
public void InsertUndoRedoOperation(UndoRedoOperation operation, object operationArgs)
{
switch (operation)
{
case UndoRedoOperation.AddStrokes:
InsertAddStrokeOperation((StrokeOperationArgs)operationArgs);
break;
case UndoRedoOperation.EraseStrokes:
InsertEraseStrokeOperation((StrokeOperationArgs)operationArgs);
break;
case UndoRedoOperation.EraseAllStrokes:
InsertEraseAllStrokesOperation((StrokeOperationArgs)operationArgs);
break;
case UndoRedoOperation.FillCell:
InsertFillCellOperation((CellOperationArgs)operationArgs);
break;
case UndoRedoOperation.EraseCell:
InsertEraseCellOperation((CellOperationArgs)operationArgs);
break;
case UndoRedoOperation.EraseAllCells:
InsertEraseAllCellsOperation((CellOperationArgs)operationArgs);
break;
case UndoRedoOperation.None:
default:
break;
}
if (operation != UndoRedoOperation.None)
{
HighestUsedTransactionId = TransactionId;
ClearRedoStack();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:UndoRedoEventArgs" /> class.
/// </summary>
/// <param name="undoRedo">The undo redo.</param>
/// <param name="action">The action.</param>
public UndoRedoEventArgs(UndoRedoOperation undoRedo, string action)
{
UndoRedo = undoRedo;
Action = action;
}
/// <summary>
/// Sets the information.
/// </summary>
/// <param name="operationToSet">The operation.</param>
/// <param name="undoDataToSet">The undo data.</param>
/// <param name="descriptionToSet">The description.</param>
public void SetInfo(UndoRedoOperation <T> operationToSet, T undoDataToSet, string descriptionToSet = "")
{
this.operation = operationToSet;
this.undoData = undoDataToSet;
this.description = descriptionToSet;
}
/// <summary>
/// Initializes a new instance of the <see cref="UndoRedoRecord{T}"/> class.
/// </summary>
/// <param name="operation">The operation.</param>
/// <param name="undoData">The undo data.</param>
/// <param name="description">The description.</param>
public UndoRedoRecord(UndoRedoOperation <T> operation, T undoData, string description = "")
{
this.SetInfo(operation, undoData, description);
}
public void SetInfo(UndoRedoOperation <T> operation, T undoData, string description = "")
{
_operation = operation;
_undoData = undoData;
_description = description;
}
public void SetInfo(UndoRedoOperation <T> operation, T undoData, string description = "")
{
m_Operation = operation;
m_UndoData = undoData;
m_Description = description;
}
public void Push(UndoRedoOperation operation)
{
UndoStack.Push(operation);
}
public UndoRedoAction(UndoRedoOperation <T> operation, T actionData)
{
_operation = operation;
_actionData = actionData;
}
