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); }