/// <summary>
/// Get (or create) an UndoRoot for the specified object or document instance.
/// </summary>
/// <param name="root">The object that represents the root of the document or object hierarchy.</param>
/// <returns>An UndoRoot instance for this object.</returns>
public UndoRoot this[object?root]
{
get
{
if (null == root)
{
return(DummyUndoRoot);
}
UndoRoot?ret = null;
if (_roots.ContainsKey(root))
{
ret = _roots[root];
}
if (null == ret)
{
ret = new UndoRoot(root);
_roots.Add(root, ret);
}
return(ret);
}
}
/// <summary>
/// Construct a Change instance with actions for undo / redo.
/// </summary>
/// <param name="instance">The instance that changed.</param>
/// <param name="propertyName">The property name that changed. (Case sensitive, used by reflection.)</param>
/// <param name="oldValue">The old value of the property.</param>
/// <param name="newValue">The new value of the property.</param>
/// <param name="descriptionOfChange">A description of this change.</param>
public virtual void OnChanging(object instance, string propertyName, object?oldValue, object?newValue,
string descriptionOfChange)
{
var supportsUndo = instance as ISupportsUndo;
if (null == supportsUndo)
{
return;
}
object?root = supportsUndo.GetUndoRoot();
if (null == root)
{
return;
}
// Add the changes to the UndoRoot
UndoRoot undoRoot = UndoService.Current[root];
if (undoRoot.IsUndoingOrRedoing)
{
return;
}
Change?change = GetChange(instance, propertyName, oldValue, newValue);
if (change is null)
{
return;
}
undoRoot.AddChange(change, descriptionOfChange);
}
/// <summary>
/// Starts an undo batch, which is ended when this instance is disposed. Designed for use in a using statement.
/// </summary>
/// <param name="root">The UndoRoot related to this instance.</param>
/// <param name="description">The description of this batch of changes.</param>
/// <param name="consolidateChangesForSameInstance">Should the batch consolidate changes.</param>
public UndoBatch(UndoRoot root, string description, bool consolidateChangesForSameInstance)
{
if (null == root)
{
return;
}
_undoRoot = root;
root.BeginChangeSetBatch(description, consolidateChangesForSameInstance);
}
/// <summary>
/// Create a ChangeSet for the specified UndoRoot.
/// </summary>
/// <param name="undoRoot">The UndoRoot that this ChangeSet belongs to.</param>
/// <param name="description">A description of the change.</param>
/// <param name="change">The Change instance that can perform the undo / redo as needed.</param>
public ChangeSet(UndoRoot undoRoot, string description, Change change)
{
_undoRoot = undoRoot;
_changes = new List <Change>();
_description = description;
if (null != change)
{
AddChange(change);
}
}
/// <summary>
/// Construct a Change instance with actions for undo / redo.
/// Returns True, if is Undoing or Redoing, otherwise False.
/// </summary>
/// <param name="instance">The instance that changed.</param>
/// <param name="propertyName">
/// The property name that exposes the collection that changed. (Case sensitive, used by
/// reflection.)
/// </param>
/// <param name="collection">The collection that had an item added / removed.</param>
/// <param name="e">The NotifyCollectionChangedEventArgs event args parameter, with info about the collection change.</param>
/// <param name="descriptionOfChange">A description of the change.</param>
public virtual bool OnCollectionChanged(object instance, string propertyName, object collection,
NotifyCollectionChangedEventArgs e, string descriptionOfChange)
{
ISupportsUndo?supportsUndo = instance as ISupportsUndo;
if (null == supportsUndo)
{
return(false);
}
object?root = supportsUndo.GetUndoRoot();
if (null == root)
{
return(false);
}
// Add the changes to the UndoRoot
UndoRoot undoRoot = UndoService.Current[root];
if (undoRoot.IsUndoingOrRedoing)
{
return(true);
}
// Create the Change instances.
IList <Change>?changes = GetCollectionChange(instance, propertyName, collection, e);
if (null == changes)
{
return(false);
}
foreach (Change change in changes)
{
undoRoot.AddChange(change, descriptionOfChange);
}
return(false);
}