private void SetDelegateView(ICollectionView collectionView)
{
if (delegateView == collectionView)
{
return;
}
IEnumerable <object> oldItems;
if (delegateView != null)
{
delegateView.CollectionChanged -= OnDelegateViewCollectionChanged;
delegateView.CurrentChanged -= OnDelegateViewCurrentChanged;
oldItems = delegateView.Cast <object>();
}
else
{
oldItems = new object[0];
}
delegateView = collectionView ?? CollectionView.Empty;
delegateView.CollectionChanged += OnDelegateViewCollectionChanged;
delegateView.CurrentChanged += OnDelegateViewCurrentChanged;
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Reset(oldItems, delegateView.Cast <object>()));
CurrentChanged.Raise(this);
}
protected override void RemoveItem(int index)
{
SortDescription sd = base [index];
base.RemoveItem(index);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Remove, sd, index);
}
public void Clear()
{
List.Clear();
RaiseCountChanged();
RaiseItemsChanged();
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
public void Insert(int index, T item)
{
List.Insert(index, item);
RaiseCountChanged();
RaiseItemsChanged();
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
}
public void Change(int year, int monthOfYear)
{
var newDayCount = GetNewDayCount(year, monthOfYear);
var oldDayCount = _dayCount;
_dayCount = newDayCount;
foreach (var day in this)
{
day.Change(year, monthOfYear);
}
var dayCountDifference = Math.Abs(newDayCount - oldDayCount);
if (oldDayCount < newDayCount)
{
var addedItems = new CalendarDay[dayCountDifference];
Array.Copy(_availableDays, oldDayCount, addedItems, 0, dayCountDifference);
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, addedItems, oldDayCount));
}
if (oldDayCount > newDayCount)
{
var removedItems = new CalendarDay[dayCountDifference];
Array.Copy(_availableDays, newDayCount, removedItems, 0, dayCountDifference);
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, newDayCount));
}
}
public void Add(T item)
{
List.Add(item);
RaiseCountChanged();
RaiseItemsChanged();
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, List.Count - 1));
}
public void Add(UIElement item)
{
children.Add(item);
SetChildParent(item);
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Add(item, children.Count));
}
public UIElement this[int index]
{
get { return(children[index]); }
set
{
if (children[index] == value)
{
return;
}
NotifyCollectionChangedEventArgs args = NotifyCollectionChangedEventArgs.Replace(children[index], value, index);
if (children[index] != null)
{
ClearChildParent(children[index]);
}
children[index] = value;
if (children[index] != null)
{
SetChildParent(children[index]);
}
CollectionChanged.Raise(this, args);
}
}
public void Insert(int index, UIElement item)
{
children.Insert(index, item);
SetChildParent(item);
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Add(item, index));
}
private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
foreach (T value in e.OldItems)
{
if (value is IContextElement)
{
((IContextElement)value).TrySetContextParent(null);
}
if (value is INotifyChanged)
{
((INotifyChanged)value).Changed -= OnItemChanged;
}
}
foreach (T value in e.NewItems)
{
if (value is IContextElement)
{
((IContextElement)value).TrySetContextParent(this);
}
if (value is INotifyChanged)
{
((INotifyChanged)value).Changed += OnItemChanged;
}
}
CollectionChanged.Raise(this, e);
RaiseChanged();
}
void AddInSubtree(StandardCollectionViewGroup group, object item, CultureInfo culture, IList <GroupDescription> descriptions, bool allowSorting)
{
int depth = group.Depth;
if (group.IsBottomLevel)
{
group.AddItem(item, allowSorting, WrappedList);
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, IndexOfSubtree(item)));
}
else
{
var desc = descriptions [group.Depth];
var groupNames = desc.GroupNameFromItem(item, group.Depth, culture);
if (groupNames is IList)
{
foreach (var name in (IList)groupNames)
{
AddInSubtree(group, item, culture, descriptions, allowSorting, name);
}
}
else
{
AddInSubtree(group, item, culture, descriptions, allowSorting, groupNames);
}
}
}
private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
foreach (T value in e.OldItems)
{
value.SetInheritanceParent(null);
if (value is Freezable)
{
(value as Freezable).Changed -= OnItemChanged;
}
}
foreach (T value in e.NewItems)
{
value.SetInheritanceParent(this);
if (value is Freezable)
{
(value as Freezable).Changed += OnItemChanged;
}
}
CollectionChanged.Raise(this, e);
RaiseChanged();
}
protected override void InsertItem(int index, TItem item)
{
base.InsertItem(index, item);
PropertyChanged.Raise(this, IndexerName);
PropertyChanged.Raise(this, CountString);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Add, item, index);
}
public void Clear()
{
NotifyCollectionChangedEventArgs e = NotifyCollectionChangedEventArgs.RemoveRange(items.Cast <object>().ToArray(), 0);
items.Clear();
CollectionChanged.Raise(this, e);
PropertyChanged.Raise(this, CountPropertyChangedEventArgs);
}
private void collection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
attemptsToRaiseChanged++;
if (raiseEvents)
{
CollectionChanged.Raise(this, e);
}
}
public void RemoveAt(int index)
{
NotifyCollectionChangedEventArgs e = NotifyCollectionChangedEventArgs.Remove(items[index], index);
items.RemoveAt(index);
CollectionChanged.Raise(this, e);
PropertyChanged.Raise(this, CountPropertyChangedEventArgs);
}
public void EndUpdate()
{
raiseEvents = true;
if (attemptsToRaiseChanged > 0)
{
CollectionChanged.Raise(this);
}
}
public T this[int index] {
get { return(List [index]); }
set {
var old = List[index];
List[index] = value;
RaiseItemsChanged();
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, old, value, index));
}
}
public void RemoveAt(int index)
{
var old = List[index];
List.RemoveAt(index);
RaiseCountChanged();
RaiseItemsChanged();
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, old, index));
}
public T this[int index]
{
get { return(array[(startIndex + index) % capacity]); }
set
{
array[(startIndex + index) % capacity] = value;
CollectionChanged.Raise(this);
}
}
protected override void SetItem(int index, TItem item)
{
var originalItem = this[index];
base.SetItem(index, item);
PropertyChanged.Raise(this, IndexerName);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Replace, originalItem, item, index);
}
protected override void SetItem(int index, SortDescription item)
{
SortDescription old = base [index];
item.Seal();
base.SetItem(index, item);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Remove, old, index);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Add, item, index);
}
private void OnSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
object[] oldInnerCollection = innerCollection;
innerCollection = TranslateCollection(SourceCollection.Cast <object>(), filterPredicate, sortKeySelector, sortDirection).ToArray();
if (innerCollection.Contains(CurrentItem))
{
SetCurrent(CurrentItem);
}
else
{
SetCurrent(CurrentItemIndex >= oldInnerCollection.Length ? innerCollection.Length : CurrentItemIndex);
}
IEnumerable <object> oldItems = e.OldItems.Intersect(oldInnerCollection).ToArray();
IEnumerable <object> newItems = e.NewItems.Intersect(innerCollection).ToArray();
if (oldItems.Count() > 1 || newItems.Count() > 1)
{
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Reset(oldInnerCollection, innerCollection));
return;
}
object oldItem = e.OldItems.FirstOrDefault();
int oldIndex = Granular.Compatibility.Array.FindIndex(oldInnerCollection, item => Granular.Compatibility.EqualityComparer <object> .Default.Equals(item, oldItem));
object newItem = e.NewItems.FirstOrDefault();
int newIndex = Granular.Compatibility.Array.FindIndex(innerCollection, item => Granular.Compatibility.EqualityComparer <object> .Default.Equals(item, newItem));
if (oldIndex == -1 && newIndex == -1 || oldItem == newItem && oldIndex == newIndex)
{
return;
}
if (Granular.Compatibility.EqualityComparer <object> .Default.Equals(oldItem, newItem))
{
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Move(newItem, oldIndex, newIndex));
}
else if (oldIndex == newIndex)
{
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Replace(oldItem, newItem, newIndex));
}
else
{
if (oldIndex != -1)
{
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Remove(oldItem, oldIndex));
}
if (newIndex != -1)
{
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.Add(newItem, newIndex));
}
}
}
protected override void RemoveItem(int index)
{
var item = this[index];
base.RemoveItem(index);
PropertyChanged.Raise(this, IndexerName);
PropertyChanged.Raise(this, CountString);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Remove, item);
}
internal void ClearSubtree()
{
ProtectedItems.Clear();
CollectionChanged.Raise(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
return;
// if (IsBottomLevel) {
// ClearItems ();
// } else {
// foreach (StandardCollectionViewGroup g in Items)
// g.ClearSubtree ();
// }
}
public void Clear()
{
ThrowIfInHandler();
try {
InHandler = true;
Mono.NativeMethods.collection_clear(native);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Reset);
} finally {
InHandler = false;
}
}
public void Clear()
{
IEnumerable <UIElement> lastChildren = children.ToArray();
children.Clear();
foreach (UIElement child in lastChildren)
{
ClearChildParent(child);
}
CollectionChanged.Raise(this, NotifyCollectionChangedEventArgs.RemoveRange(lastChildren, 0));
}
public void RemoveAt(int index)
{
ThrowIfInHandler();
try {
InHandler = true;
var oldItem = this [index];
Mono.NativeMethods.collection_remove_at(native, index);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Remove, oldItem, index);
} finally {
InHandler = false;
}
}
private void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
OnPropertyChanged("Count");
OnPropertyChanged("Item[]");
try
{
CollectionChanged.Raise(this, e);
}
catch (NotSupportedException)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
}
public void Insert(int index, T item)
{
ThrowIfInHandler();
try {
InHandler = true;
Value v;
using ((v = Value.FromObject(item)))
Mono.NativeMethods.collection_insert(native, index, ref v);
CollectionChanged.Raise(this, NotifyCollectionChangedAction.Add, item, index);
} finally {
InHandler = false;
}
}
