public void BeforeEach()
{
_trackerMock = new Mock<ITracker<TrackableModel, ITrackableViewModel>>();
_model = new TrackableModel("test", 1);
_models = new Collection<TrackableModel>();
_trackerMock.Setup(t => t.ConvertAndTrack(_model)).Returns<TrackableModel>(model => new TrackableViewModel(model)).Verifiable();
_trackerMock.Setup(t => t.ConvertAndTrack(_models)).Returns<IEnumerable<TrackableModel>>(models =>
{
var viewModels = new Collection<ITrackableViewModel>();
foreach (var model in models)
{
viewModels.Add(new TrackableViewModel(model));
}
return viewModels;
}).Verifiable();
_trackedCollection = new TrackedCollection<TrackableModel, ITrackableViewModel>(_models, _trackerMock.Object);
_trackedCollection.AddTracked(_model);
}
public Toolbox()
{
this.Nails = new TrackedCollection <Nail>(CollectionTrackingStrategy.TrackAllContent);
for (int i = 0; i < _random.Next(13); ++i)
{
this.Nails.Add(new Nail());
}
this.CreateNewHammer();
}
public Model()
{
VertexData = new VertexData();
Subsets = new Collection<MeshSubset>();
Indices = new TrackedCollection<int>();
Textures = new TrackedCollection<string>();
Materials = new TrackedCollection<Material>();
VertexData.Changed += (o, e) => OnPropertyChanged("VertexData");
Indices.Changed += (o, e) => OnPropertyChanged("Indices");
Textures.Changed += (o, e) => OnPropertyChanged("Textures");
Materials.Changed += (o, e) => OnPropertyChanged("Materials");
}
public T this[int index]
{
get
{
if ((index < 0) || (index >= inner.combinedValues.Count))
{
throw new ArgumentOutOfRangeException(nameof(index));
}
TrackedCollection <T> .ValueEl el = inner.combinedValues[index];
if (el.isInserted)
{
return(el.insertedValue);
}
else
{
return(el.originalValue.Right); // Right == current value
}
}
set
{
inner.MarkChange();
if ((index < 0) || (index >= inner.combinedValues.Count))
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
TrackedCollection <T> .ValueEl el = inner.combinedValues[index];
if (el.isInserted)
{
el.insertedValue = value;
}
else
{
el.originalValue.Right = value;
}
}
}
public void Insert_WhenCalledAndReverted_InsertsAndReverts()
{
TrackedCollection<int> tc = new TrackedCollection<int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.Insert(0, 10);
Assert.IsTrue(tc[0] == 10);
tc.Tracker.Undo();
Assert.IsTrue(tc[0] == 0);
Assert.IsFalse(tc.Contains( 10 ));
}
public void Insert_WhenCalledAndReverted_InsertsAndReverts()
{
TrackedCollection <int> tc = new TrackedCollection <int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.Insert(0, 10);
Assert.IsTrue(tc[0] == 10);
tc.Tracker.Undo();
Assert.IsTrue(tc[0] == 0);
Assert.IsFalse(tc.Contains(10));
}
public void RemoveAt_WhenCalledAndReverted_RemovesAndReverts()
{
TrackedCollection <int> tc = new TrackedCollection <int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.RemoveAt(1);
Assert.IsFalse(tc.Contains(1));
Assert.IsTrue(tc[1] == 2);
tc.Tracker.Undo();
Assert.IsTrue(tc[1] == 1);
Assert.IsTrue(tc.Contains(1));
}
public void RemoveAt_WhenCalledAndReverted_RemovesAndReverts()
{
TrackedCollection<int> tc = new TrackedCollection<int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.RemoveAt(1);
Assert.IsFalse(tc.Contains(1));
Assert.IsTrue(tc[1] == 2);
tc.Tracker.Undo();
Assert.IsTrue(tc[1] == 1);
Assert.IsTrue(tc.Contains(1));
}
public void CleanUp()
{
foreach (ModelItem modelItem in TrackedModelItem.Keys)
{
modelItem.PropertyChanged -= new ComponentModel.PropertyChangedEventHandler(modelItem_PropertyChanged);
}
TrackedModelItem.Clear();
foreach (INotifyCollectionChanged collection in TrackedCollection)
{
collection.CollectionChanged -= new Collections.Specialized.NotifyCollectionChangedEventHandler(collection_CollectionChanged);
}
TrackedCollection.Clear();
//remove childViewModels
foreach (TreeViewItemViewModel child in ChildViewModels)
{
this.Parent.InternalChildren.Remove(child);
child.CleanUp();
}
this.ChildViewModels.Clear();
}
public void Insert(int index, T value)
{
inner.MarkChange();
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if ((index < 0) || (index > inner.combinedValues.Count))
{
throw new ArgumentOutOfRangeException(nameof(index));
}
TrackedCollection <T> .ValueEl el = new TrackedCollection <T> .ValueEl();
el.isInserted = true;
el.insertedValue = value;
inner.combinedValues.Insert(index, el);
}
public void Undo_WhenCalledAfterClear_RevertsClear()
{
TrackedCollection <int> tc = new TrackedCollection <int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.Clear();
Assert.IsTrue(tc.Count == 0);
tc.Tracker.Undo();
Assert.IsTrue(tc.Count == 3);
Assert.IsTrue(tc[0] == 0);
Assert.IsTrue(tc[1] == 1);
Assert.IsTrue(tc[2] == 2);
}
//
// Load/Store implementation
//
internal void Load(List <T> values)
{
// To support reload
inner.combinedValues.Clear();
inner.removedValues.Clear();
foreach (T value in values)
{
// If T was a mutable reference type, would need to make a copy of value
// for the left-side of the Pair, so that changes to the value in the
// right-side wouldn't also change the left-side value (due to aliasing).
// However, we constrain T to be either a value type or a immutable ref type (e.g., string)
// to avoid this problem.
TrackedCollection <T> .ValueEl el = new TrackedCollection <T> .ValueEl();
el.isInserted = false;
el.originalValue = new Pair <T, T>(value, value);
inner.combinedValues.Add(el);
}
}
public void Add_WhenCalledAndReverted_AddsAndReverts()
{
TrackedCollection<int> tc = new TrackedCollection<int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add( 0 );
tc.Add(1);
tc.Add(2);
tc.Add(3);
tc.Add(4);
tc.Add(5);
ObjectTracker.SetRestorePoint(tc, "After 5");
tc.Add(6);
tc.Add(7);
tc.Add(8);
tc.Add(9);
tc.Add(10);
ObjectTracker.UndoTo(tc, "After 5");
Assert.AreEqual(5, tc.Last());
tc.Tracker.Redo();
Assert.AreEqual(6, tc.Last());
tc.Tracker.Undo();
Assert.AreEqual(5, tc.Last());
tc.Tracker.Undo();
Assert.AreEqual(4, tc.Last());
}
public void Add_WhenCalledAndReverted_AddsAndReverts()
{
TrackedCollection <int> tc = new TrackedCollection <int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.Add(3);
tc.Add(4);
tc.Add(5);
ObjectTracker.SetRestorePoint(tc, "After 5");
tc.Add(6);
tc.Add(7);
tc.Add(8);
tc.Add(9);
tc.Add(10);
ObjectTracker.UndoTo(tc, "After 5");
Assert.AreEqual(5, tc.Last());
tc.Tracker.Redo();
Assert.AreEqual(6, tc.Last());
tc.Tracker.Undo();
Assert.AreEqual(5, tc.Last());
tc.Tracker.Undo();
Assert.AreEqual(4, tc.Last());
}
public void RemoveAt(int index)
{
inner.MarkChange();
if ((index < 0) || (index >= inner.combinedValues.Count))
{
throw new ArgumentOutOfRangeException(nameof(index));
}
TrackedCollection <T> .ValueEl el = inner.combinedValues[index];
if (el.isInserted)
{
// We're removing an inserted value.
inner.combinedValues.RemoveAt(index);
}
else
{
// We're removing an original value.
Pair <T, T> pair = inner.combinedValues[index].originalValue;
inner.combinedValues.RemoveAt(index);
inner.removedValues.Add(pair.Left);
}
}
//
// Internal constructors
//
internal ValueCollectionEnumerator(TrackedCollection <T> trackingList, List <TrackedCollection <T> .ValueEl> combinedValues)
{
inner = new TrackedCollectionEnumerator <T>("ValueCollectionEnumerator", trackingList, combinedValues);
}
public void Undo_WhenCalledAfterClear_RevertsClear()
{
TrackedCollection<int> tc = new TrackedCollection<int>(CollectionTrackingStrategy.TrackOnlyCollectionOperations);
tc.Tracker.Track();
tc.Add(0);
tc.Add(1);
tc.Add(2);
tc.Clear();
Assert.IsTrue(tc.Count == 0);
tc.Tracker.Undo();
Assert.IsTrue(tc.Count == 3);
Assert.IsTrue(tc[0] == 0);
Assert.IsTrue(tc[1] == 1);
Assert.IsTrue(tc[2] == 2);
}
public SequenceSpan()
{
_spans = new TrackedCollection<Span>();
_spans.Added += new EventHandler<TrackedCollectionEventArgs<Span>>(_spans_Added);
_spans.Removed += new EventHandler<TrackedCollectionEventArgs<Span>>(_spans_Removed);
}
