private DemoCollection(
ReadOnlyCollection <T> sourceItems,
ObservableCollectionPlus <T> activeItems,
int minCount,
int maxCount,
int initialCount)
: base(activeItems)
{
Contract.Requires(activeItems != null);
Contract.Requires(sourceItems != null);
Contract.Requires(sourceItems.Count > 0);
m_minCount = minCount;
m_maxCount = maxCount;
m_initialCount = initialCount;
m_activeItems = activeItems;
m_sourceItems = sourceItems;
m_addCommand = new DelegateCommand(Add, () => canAddOrInsert);
m_insertCommand = new DelegateCommand(Insert, () => canAddOrInsert);
m_removeCommand = new DelegateCommand(Remove, () => canRemove);
m_moveCommand = new DelegateCommand(Move, () => canMove);
m_changeCommand = new DelegateCommand(Change, () => canChange);
m_resetCommand = new DelegateCommand(Reset);
activeItems.CollectionChanged += (sender, e) =>
{
m_removeCommand.RaiseCanExecuteChanged();
m_addCommand.RaiseCanExecuteChanged();
m_moveCommand.RaiseCanExecuteChanged();
m_changeCommand.RaiseCanExecuteChanged();
m_insertCommand.RaiseCanExecuteChanged();
};
}
public static void Synchronize <TSource, TTarget>(this ObservableCollectionPlus <TTarget> targetCollection, IList <TSource> sourceCollection, Func <TSource, TTarget, bool> matcher, Func <TSource, TTarget> mapper) where TSource : IEquatable <TSource>
{
Contract.Requires(targetCollection != null);
Contract.Requires(mapper != null);
Contract.Requires(sourceCollection != null);
Contract.Requires(sourceCollection.AllUnique());
using (targetCollection.BeginMultiUpdate())
{
// move wrappers around to the right places
// or create a new one
for (int i = 0; i < sourceCollection.Count; i++)
{
var sourceItem = sourceCollection[i];
var targetIndex = targetCollection.IndexOf(targetItem => matcher(sourceItem, targetItem));
if (targetIndex >= 0)
{
if (targetIndex != i)
{
Debug.Assert(targetIndex > i, "this would only happen if we have duplicates...which we should never have!");
targetCollection.Move(targetIndex, i);
}
else
{
// NOOP - already in the right spot! :-)
}
}
else
{
var newItem = mapper(sourceItem);
Debug.Assert(matcher(sourceItem, newItem));
targetCollection.Insert(i, newItem);
}
}
// Remove anything left
while (targetCollection.Count > sourceCollection.Count)
{
targetCollection.RemoveLast();
}
Debug.Assert(sourceCollection.Count == targetCollection.Count);
#if DEBUG
for (int i = 0; i < sourceCollection.Count; i++)
{
Debug.Assert(matcher(sourceCollection[i], targetCollection[i]));
}
#endif
}
}
public static DemoCollection <T> Create(IList <T> source, int initialCount, int minCount, int maxCount)
{
Contract.Requires(source != null);
Contract.Requires(source.Count > 0);
Contract.Requires(initialCount >= 0);
Contract.Requires(minCount >= 0);
Contract.Requires(minCount <= initialCount);
Contract.Requires(initialCount <= maxCount);
var sourceItems = source.ToReadOnlyCollection();
var observableCollection = new ObservableCollectionPlus <T>();
for (int i = 0; i < initialCount; i++)
{
observableCollection.Add(sourceItems[i % sourceItems.Count]);
}
return(new DemoCollection <T>(sourceItems, observableCollection, minCount, maxCount, initialCount));
}
