public UndoObject(bool addInstance)
{
if (!addInstance)
{
return;
}
FieldObject = new UndoObject
{
FieldInteger = 1,
FieldFloat = 1.1f,
FieldObject = new UndoObject(),
PropertyFloat = 1.1f,
PropertyInteger = 1,
PropertyObject = null
};
PropertyObject = new UndoObject
{
FieldInteger = -1,
FieldFloat = -1.1f,
FieldObject = null,
PropertyFloat = -1.1f,
PropertyInteger = -1,
PropertyObject = new UndoObject()
};
}
/// <summary>
/// Handles a change to the IsLayoutFrozen dependency property.
/// </summary>
/// <param name="dependencyObject">The object that owns the property.</param>
/// <param name="dependencyPropertyChangedEventArgs">A description of the changed property.</param>
private static void OnIsLayoutFrozenChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
// The layout controls the relative size of the row and column headers.
UndoObject undoObject = new UndoObject(dependencyPropertyChangedEventArgs.OldValue, dependencyPropertyChangedEventArgs.NewValue, UndoAction.Create);
DynamicReport.SetIsLayoutFrozen.Execute(undoObject, dependencyObject as DynamicReport);
}
public UndoObject(UndoObject undoObject)
{
this.OperationType = undoObject.OperationType;
this.Index = undoObject.Index;
this.Shift = undoObject.Shift;
this.Data = undoObject.Data;
}
public override void Load()
{
m_UndoManager = Session.GetManager <IUndoManager>();
m_Undo = ScriptableObject.CreateInstance <UndoObject>();
m_Undo.hideFlags |= HideFlags.HideAndDontSave;
m_Undo.Undo += HandleUndo;
m_Undo.Redo += HandleRedo;
m_UndoManager.ChangeRecorded += HandleChangeRecorded;
}
public void UndoBtn()
{
if (!first_click)
{
first_click = true;
GameObject toolTip = Resources.Load <GameObject>("Prefabs/ToolTipPref");
//toolTip.GetComponent<ToolTipController>().setMessage("Undo position of object");
//GameObject.Instantiate(toolTip);
}
if (com.cmd.Count > 0)
{
UndoObject tmp = com.cmd.Pop();
if (tmp.Item.gameObject == null)
{
Debug.Log("ObjectNull");
return;
}
if (tmp.Opt == Operation.Delete)
{
print(tmp.Item.name);
Instantiate(tmp.Item);
}
if (tmp.Opt == Operation.Rotate)
{
print(tmp.Rot);
tmp.Item.transform.rotation = Quaternion.Euler(0, 0, tmp.Rot);
}
if (tmp.Opt == Operation.Create)
{
Debug.Log("Object Created");
Destroy(tmp.Item);
}
if (tmp.Opt == Operation.Resize)
{
print(tmp.Item.name);
Debug.Log("Resize get?");
tmp.Item.transform.GetComponent <RectTransform>().sizeDelta = tmp.Rect;
Debug.Log(tmp.Rect.x);
}
if (tmp.Opt == Operation.Drag)
{
var tr = GameObject.Find(tmp.Item.name).transform;
//print("Exist: "+tr.position);
print("InList: " + tmp.Item.transform.position);
tmp.Item.transform.SetAsLastSibling();
tmp.Item.transform.position = tmp.Trans;
}
}
}
public void UndoTestRecursive2()
{
var undo = new Undo();
var instance = new UndoObject(true)
{
FieldObject =
{
FieldObject = new UndoObject(false),
PropertyObject = new UndoObject(false)
},
PropertyObject =
{
FieldObject = new UndoObject(false),
PropertyObject = new UndoObject(false)
}
};
using (new UndoBlock(undo, instance, "Edit"))
{
instance.FieldInteger = 1;
instance.FieldObject.FieldInteger = 10;
instance.PropertyObject.FieldInteger = 11;
instance.FieldObject.FieldObject.FieldInteger = 22;
instance.FieldObject.PropertyObject.FieldInteger = 23;
instance.PropertyObject.FieldObject.FieldInteger = 24;
instance.PropertyObject.PropertyObject.FieldInteger = 25;
}
undo.PerformUndo();
Assert.AreEqual(10, instance.FieldInteger);
Assert.AreEqual(1, instance.FieldObject.FieldInteger);
Assert.AreEqual(-1, instance.PropertyObject.FieldInteger);
Assert.AreEqual(10, instance.FieldObject.FieldObject.FieldInteger);
Assert.AreEqual(10, instance.FieldObject.PropertyObject.FieldInteger);
Assert.AreEqual(10, instance.PropertyObject.FieldObject.FieldInteger);
Assert.AreEqual(10, instance.PropertyObject.PropertyObject.FieldInteger);
undo.PerformRedo();
Assert.AreEqual(1, instance.FieldInteger);
Assert.AreEqual(10, instance.FieldObject.FieldInteger);
Assert.AreEqual(11, instance.PropertyObject.FieldInteger);
Assert.AreEqual(22, instance.FieldObject.FieldObject.FieldInteger);
Assert.AreEqual(23, instance.FieldObject.PropertyObject.FieldInteger);
Assert.AreEqual(24, instance.PropertyObject.FieldObject.FieldInteger);
Assert.AreEqual(25, instance.PropertyObject.PropertyObject.FieldInteger);
}
private static void BasicUndoRedo(Undo undo, UndoObject instance)
{
Assert.AreEqual("Basic", undo.FirstUndoName);
undo.PerformUndo();
Assert.AreEqual(10, instance.FieldInteger);
Assert.AreEqual(0.1f, instance.FieldFloat);
Assert.AreNotEqual(null, instance.FieldObject);
Assert.AreEqual(-10, instance.PropertyInteger);
Assert.AreEqual(-0.1f, instance.PropertyFloat);
Assert.AreNotEqual(null, instance.PropertyObject);
Assert.AreEqual("Basic", undo.FirstRedoName);
undo.PerformRedo();
Assert.AreEqual(0, instance.FieldInteger);
Assert.AreEqual(0, instance.FieldFloat);
Assert.AreEqual(null, instance.FieldObject);
Assert.AreEqual(0, instance.PropertyInteger);
Assert.AreEqual(0, instance.PropertyFloat);
Assert.AreEqual(null, instance.PropertyObject);
}
public void UndoTestRecursive()
{
var undo = new Undo();
var instance = new UndoObject(true);
undo.RecordAction(instance, "Basic", (i) =>
{
i.FieldObject = new UndoObject();
i.FieldObject.FieldObject = new UndoObject();
i.FieldObject.FieldObject.FieldObject = new UndoObject();
i.FieldObject.FieldObject.PropertyObject = new UndoObject();
i.FieldObject.FieldObject.PropertyObject.FieldInteger = 99;
i.PropertyObject = new UndoObject();
i.PropertyObject.PropertyObject = new UndoObject();
i.PropertyObject.PropertyObject.PropertyObject = new UndoObject();
i.PropertyObject.PropertyObject.FieldObject = new UndoObject();
i.PropertyObject.PropertyObject.FieldObject.FieldInteger = 99;
});
undo.PerformUndo();
Assert.AreNotEqual(null, instance.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject);
Assert.AreEqual(null, instance.FieldObject.FieldObject.FieldObject);
Assert.AreEqual(null, instance.FieldObject.FieldObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject);
Assert.AreEqual(null, instance.PropertyObject.PropertyObject.PropertyObject);
Assert.AreEqual(null, instance.PropertyObject.PropertyObject.FieldObject);
undo.PerformRedo();
Assert.AreNotEqual(null, instance.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject.FieldObject);
Assert.AreEqual(99, instance.FieldObject.FieldObject.PropertyObject.FieldInteger);
Assert.AreEqual(99, instance.PropertyObject.PropertyObject.FieldObject.FieldInteger);
}
/// <summary>
/// Freezes or unfreezes the layout of the column and row header panels.
/// </summary>
/// <param name="sender">The object that originated the routed event.</param>
/// <param name="routedEventArgs">The routed event arguments.</param>
public void OnSetIsLayoutFrozen(Object sender, RoutedEventArgs routedEventArgs)
{
// The idea is to extract the parameters from the event data and set frozen state of the panel layout based on the
// values provided.
ExecutedRoutedEventArgs executedRoutedEventArgs = routedEventArgs as ExecutedRoutedEventArgs;
// The simplest form for this command simply passes in a value. The command parameter is burpped back up to the
// property which then issues a command back here with the proper Undo information encoded in the command. The idea is
// to simplify the calling parameters for an externally invoked command while still maintaining a consistent format
// internally for handling the undo/redo operations.
if (executedRoutedEventArgs.Parameter is Boolean)
{
SetValue(DynamicReport.IsLayoutFrozenProperty, (Boolean)executedRoutedEventArgs.Parameter);
}
// This parameter format handles the undo/redo logic.
if (this.reportGrid != null && executedRoutedEventArgs.Parameter is UndoObject)
{
// Extract the parameter and do the actual work involved with freezing the panes.
UndoObject undoObject = executedRoutedEventArgs.Parameter as UndoObject;
this.reportGrid.FreezePanes((Boolean)undoObject.NewValue, undoObject.UndoAction);
// Once the command is finished, this will broadcast the event. The primary consumer is the Undo logic which will
// save the event data on the Undo or Redo stack and can replay it when needed.
RaiseEvent(new UndoPropertyChangedEventArgs(DynamicReport.UndoPropertyChangedEvent, undoObject.UndoAction,
DynamicReport.IsLayoutFrozenProperty, undoObject.OldValue, undoObject.NewValue));
// The property must be set when this operation is called from the Undo or Redo methods. However, setting the
// value will lead the logic right back here. This will inhibit the command processing while the Undone or Redone
// value is restored.
if (undoObject.UndoAction == UndoAction.Undo || undoObject.UndoAction == UndoAction.Redo)
{
this.CommandBindings.Remove(this.reportGrid.commandBingingMap[DynamicReport.SetIsLayoutFrozen]);
SetValue(DynamicReport.IsLayoutFrozenProperty, undoObject.NewValue);
this.CommandBindings.Add(this.reportGrid.commandBingingMap[DynamicReport.SetIsLayoutFrozen]);
}
}
}
public void UndoTestBasic()
{
var undo = new Undo();
var instance = new UndoObject(true);
undo.RecordBegin(instance, "Basic");
instance.FieldFloat = 0;
instance.FieldInteger = 0;
instance.FieldObject = null;
instance.PropertyFloat = 0;
instance.PropertyInteger = 0;
instance.PropertyObject = null;
undo.RecordEnd();
BasicUndoRedo(undo, instance);
instance = new UndoObject(true);
undo.RecordAction(instance, "Basic", () =>
{
instance.FieldFloat = 0;
instance.FieldInteger = 0;
instance.FieldObject = null;
instance.PropertyFloat = 0;
instance.PropertyInteger = 0;
instance.PropertyObject = null;
});
BasicUndoRedo(undo, instance);
object generic = new UndoObject(true);
undo.RecordAction(generic, "Basic", (i) =>
{
((UndoObject)i).FieldFloat = 0;
((UndoObject)i).FieldInteger = 0;
((UndoObject)i).FieldObject = null;
((UndoObject)i).PropertyFloat = 0;
((UndoObject)i).PropertyInteger = 0;
((UndoObject)i).PropertyObject = null;
});
BasicUndoRedo(undo, (UndoObject)generic);
instance = new UndoObject(true);
undo.RecordAction(instance, "Basic", (i) =>
{
i.FieldFloat = 0;
i.FieldInteger = 0;
i.FieldObject = null;
i.PropertyFloat = 0;
i.PropertyInteger = 0;
i.PropertyObject = null;
});
BasicUndoRedo(undo, instance);
instance = new UndoObject(true);
using (new UndoBlock(undo, instance, "Basic"))
{
instance.FieldFloat = 0;
instance.FieldInteger = 0;
instance.FieldObject = null;
instance.PropertyFloat = 0;
instance.PropertyInteger = 0;
instance.PropertyObject = null;
}
BasicUndoRedo(undo, instance);
}
public void Push(UndoObject value)
{
if (_list.Count == _max)
_list.RemoveLast();
_list.AddFirst(value);
}
public void SaveRedo(UndoObject redoObject)
{
this.RedoStack.Push(redoObject);
this.IsRedoable = true;
}
public void SaveUndo(UndoObject undoObject)
{
this.UndoStack.Push(undoObject);
this.IsUndoable = true;
}
private void RestoreState(UndoObject undoObject)
{
switch (undoObject.OperationType)
{
case UndoOperationType.WorkerEdit:
Workers.WorkerListReplaceItem(undoObject.Index, ((Worker)undoObject.Data).Clone());
break;
case UndoOperationType.WorkersPowerCost:
Workers.PowerCost = (double)undoObject.Data;
break;
case UndoOperationType.WorkersCoinType:
Workers.CoinType = (string)undoObject.Data;
break;
case UndoOperationType.WorkersDisplayCoinAs:
Workers.DisplayCoinAs = (string)undoObject.Data;
break;
case UndoOperationType.WorkerAdd:
Workers.WorkerListRemoveAt(Workers.WorkerList.Count - 1);
break;
case UndoOperationType.WorkerAddRange:
Workers.WorkerListRemoveRangeAt(undoObject.Index, (int)undoObject.Data);
break;
case UndoOperationType.WorkerInsert:
Workers.WorkerListRemoveAt(undoObject.Index);
break;
case UndoOperationType.WorkerRemove:
Workers.WorkerListInsert(undoObject.Index, ((Worker)undoObject.Data).Clone());
break;
case UndoOperationType.WorkerRemoveRange:
Workers.WorkerListAddRangeAt((ObservableCollection <Worker>)undoObject.Data, undoObject.Index);
break;
case UndoOperationType.WorkerMove:
Workers.WorkerListMove((int)undoObject.Data, undoObject.Index);
break;
case UndoOperationType.SettingsEdit:
UnHookUpWmtSettingsPropertyChangeEvents();
SaveUndoRedo("WtmSettings");
var wtms = ((WtmSettingsObject)undoObject.Data).Clone();
bool switchTimeFromEqual = WtmSwitchTimeFromStored.Equals(wtms.SwitchTimeFrom);
bool switchTimeToEqual = WtmSwitchTimeToStored.Equals(wtms.SwitchTimeTo);
bool historicalAverageEqual = WtmHistoricalAveragePeriodStored == wtms.HistoricalAveragePeriod;
bool historyTimeFromEqual = WtmHistoryTimeFromStored.Equals(wtms.HistoryTimeFrom);
bool historyTimeToEqual = WtmHistoryTimeToStored.Equals(wtms.HistoryTimeTo);
WtmSettings = wtms;
HookUpWmtSettingsPropertyChangeEvents();
if (WtmSettings.AutoSwitch)
{
SwitchTimeIsUpdated = false;
}
if (WtmSettings.BackupHistoricalPrices)
{
HistoryTimeIsUpdated = false;
}
WtmSettings.ServerSettingsAreUpdated = true;
break;
case UndoOperationType.WorkersAll:
SaveUndoRedo("WorkersAll");
var allWorkers = undoObject.Data as ObservableCollection <Worker>;
Workers.WorkerList.Clear();
foreach (var worker in allWorkers)
{
Workers.WorkerList.Add(worker.Clone());
}
break;
}
}
private UndoObject SaveState(string propertyName)
{
UndoObject undoObject = null;
var index = Workers.WorkerIndex;
int count = Workers.WorkerCount;
switch (propertyName)
{
case "WorkersPowerCost":
undoObject = new UndoObject(UndoOperationType.WorkersPowerCost, -1, Workers.PowerCost);
break;
case "WorkersCoinType":
undoObject = new UndoObject(UndoOperationType.WorkersCoinType, -1, Workers.CoinType);
break;
case "WorkersDisplayCoinAs":
undoObject = new UndoObject(UndoOperationType.WorkersDisplayCoinAs, -1, Workers.DisplayCoinAs);
break;
case "WorkerList":
undoObject = new UndoObject(UndoOperationType.WorkerEdit, index, Workers.WorkerList[index].CloneNoEvents());
break;
case "WorkerAdd":
undoObject = new UndoObject(UndoOperationType.WorkerAdd, -1, null);
break;
case "WorkerAddRange":
undoObject = new UndoObject(UndoOperationType.WorkerAddRange, index, count);
break;
case "WorkerInsert":
undoObject = new UndoObject(UndoOperationType.WorkerInsert, index, Workers.WorkerList[index].CloneNoEvents());
break;
case "WorkerRemove":
undoObject = new UndoObject(UndoOperationType.WorkerRemove, index, Workers.WorkerList[index].CloneNoEvents());
break;
case "WorkerRemoveRange":
var newWorkerList = new ObservableCollection <Worker>();
for (int i = 0; i < count; i++)
{
newWorkerList.Add(Workers.WorkerList[index + i + 1].CloneNoEvents());
}
undoObject = new UndoObject(UndoOperationType.WorkerRemoveRange, index, newWorkerList);
break;
case "WorkerMove":
undoObject = new UndoObject(UndoOperationType.WorkerMove, index, Workers.WorkerNewIndex);
break;
case "WtmSettings":
undoObject = new UndoObject(UndoOperationType.SettingsEdit, -1, WtmSettings.Clone());
break;
case "WorkersAll":
var newAllWorkers = new ObservableCollection <Worker>();
foreach (var worker in Workers.WorkerList)
{
newAllWorkers.Add(worker.CloneNoEvents());
}
undoObject = new UndoObject(UndoOperationType.WorkersAll, -1, newAllWorkers);
break;
}
return(undoObject);
}
