protected void RemoveDependencySource(string name, INotifyCollectionChanged source)
{
ArgumentValidation.NotNullOrEmpty <char>(name, "name");
ArgumentValidation.NotNull(source, "source");
CollectionChangedEventManager.RemoveListener(source, this);
_collectionSources.Value.Remove(source);
}
/// <summary>
/// Assigns an enumeration that serves as a source for this list.
/// </summary>
/// <param name="sourceList">The new source, or <see langword="null"/> if the current list should manage its own items.</param>
internal void SetSourceList(System.Collections.IEnumerable sourceList)
{
if (this.sourceList == sourceList)
{
return;
}
var observable = this.sourceList as INotifyCollectionChanged;
if (observable != null)
{
CollectionChangedEventManager.RemoveListener(observable, this.sourceListChangeListener);
}
lockForSourceList = false;
this.Clear();
this.sourceList = sourceList;
if (sourceList != null)
{
ReloadSourceList();
observable = this.sourceList as INotifyCollectionChanged;
if (observable != null)
{
CollectionChangedEventManager.AddListener(observable, this.sourceListChangeListener);
}
}
}
public virtual bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
{
var ccea = (NotifyCollectionChangedEventArgs)e;
if (ReferenceEquals(sender, this.Source))
{
var oldItems = ccea.OldItems;
if (oldItems != null)
{
foreach (var incc in oldItems.OfType <INotifyCollectionChanged>())
{
CollectionChangedEventManager.RemoveListener(incc, this);
}
}
var newItems = ccea.NewItems;
if (newItems != null)
{
foreach (var incc in newItems.OfType <INotifyCollectionChanged>())
{
CollectionChangedEventManager.AddListener(incc, this);
}
}
}
return(true);
}
/// <summary>
/// Provides derived classes an opportunity to handle changes to the <see cref="Appointments"/>.
/// </summary>
protected virtual void OnAppointmentsChanged(DependencyPropertyChangedEventArgs args)
{
var oldAppointments = args.OldValue as INotifyCollectionChanged;
if (oldAppointments != null)
{
CollectionChangedEventManager.RemoveListener(oldAppointments, this);
}
if (args.OldValue != null)
{
foreach (IAppointment unhook in (IList)args.OldValue)
{
this.UnHookNewAppointment(unhook);
}
}
var newAppointments = args.NewValue as INotifyCollectionChanged;
if (newAppointments != null)
{
CollectionChangedEventManager.AddListener(newAppointments, this);
}
if (args.NewValue != null)
{
foreach (IAppointment hook in (IList)args.NewValue)
{
this.HookNewAppointment(hook);
}
}
}
/// <summary>
/// Called whenever one of the inner collection changed.
/// </summary>
/// <param name="managerType">Type of the manager we subscribed to.</param>
/// <param name="sender">The collection that sent the event.</param>
/// <param name="e">Information about the event.</param>
/// <returns>True if was able to perform the required operation.</returns>
/// <remarks><see cref="IWeakEventListener"/> implementation.</remarks>
public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
{
if (TargetObject != null && TargetProperty != null)
{
if (managerType == typeof(CollectionChangedEventManager))
{
// Update only if collection change event args matches the allowed actions for notification:
if (e is NotifyCollectionChangedEventArgs collectionargs && ActionsToNotify.HasFlag(collectionargs.Action))
{
// Update binding target when collection changed:
if (updateTargetAction != null)
{
if (Application.Current.Dispatcher.CheckAccess())
{
updateTargetAction.Invoke();
}
else
{
Application.Current.Dispatcher.BeginInvoke(updateTargetAction);
}
}
}
}
}
else if (sender is INotifyCollectionChanged collection)
{
CollectionChangedEventManager.RemoveListener(collection, this); // our binding expression is not used anymore, we can shut listening down.
}
return(true); // always return true otherwise ugly exception happen in the framework core.
}
private void CleanHeadersFootersNotification(HeadersFootersGeneratorNode node)
{
var collection = node.Items as INotifyCollectionChanged;
if (collection == null)
{
return;
}
try
{
var nodeList = m_headersFootersMapping[collection];
nodeList.Remove(node);
if (nodeList.Count == 0)
{
CollectionChangedEventManager.RemoveListener(collection, this);
m_headersFootersMapping.Remove(collection);
}
}
catch (Exception e)
{
throw new DataGridInternalException(e.Message, e, this.DataGridControl);
}
}
private void UnregisterNodeCollectionChanged(INotifyCollectionChanged source)
{
if (m_nodesCollectionChangedEventHandlers.Remove(source))
{
CollectionChangedEventManager.RemoveListener(source, this);
}
}
protected override void Uninitialize()
{
BindingOperations.ClearBinding(this,
TableViewColumnVirtualizationManager.FixedColumnCountProperty);
BindingOperations.ClearBinding(this,
TableViewColumnVirtualizationManager.IsVirtualizingProperty);
BindingOperations.ClearBinding(this,
TableViewColumnVirtualizationManager.FirstColumnCompensationOffsetProperty);
if (m_scrollViewer != null)
{
m_scrollViewer.ScrollChanged -= new ScrollChangedEventHandler(this.ScrollViewer_ScrollChanged);
}
ColumnActualWidthEventManager.RemoveListener(this.DataGridContext.Columns, this);
DataGridControlTemplateChangedEventManager.RemoveListener(this.DataGridContext.DataGridControl, this);
CollectionChangedEventManager.RemoveListener(this.DataGridContext.Items.SortDescriptions, this);
CollectionChangedEventManager.RemoveListener(this.DataGridContext.Items.GroupDescriptions, this);
base.Uninitialize();
}
private static void OnDataGridContextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
GroupLevelIndicatorPane self = sender as GroupLevelIndicatorPane;
if (self != null)
{
DataGridContext dataGridContext = e.OldValue as DataGridContext;
//unregister to the old contexts Collection GroupDescriptions Changed event
if (dataGridContext != null)
{
CollectionChangedEventManager.RemoveListener(dataGridContext.Items.GroupDescriptions, self);
}
dataGridContext = e.NewValue as DataGridContext;
//register to the new contexts Collection GroupDescriptions Changed event
if (dataGridContext != null)
{
CollectionChangedEventManager.AddListener(dataGridContext.Items.GroupDescriptions, self);
self.PrepareDefaultStyleKey(dataGridContext.DataGridControl.GetView());
}
self.InvalidateMeasure();
}
}
/// <summary>
/// Stops listening for change events.
/// </summary>
/// <param name="list">The list to stop listening to.</param>
protected void StopListeningForChangeEvents(IList list)
{
if (list is INotifyCollectionChanged)
{
CollectionChangedEventManager.RemoveListener((INotifyCollectionChanged)list, this);
}
}
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
// Cleanup managed resources
CollectionChangedEventManager.RemoveListener(this.sourceCollection, this);
if (this.teardown != null)
{
foreach (var target in this.Items)
{
this.teardown(target);
}
}
this.Items.Clear();
}
// Cleanup unmanaged resources
// Mark the object as disposed
this.disposed = true;
}
}
/// <summary>
/// Removes the weak event listener for a CollectionChanged event.
/// </summary>
/// <param name="source">The source of the event.</param>
/// <param name="handler">The event handler.</param>
/// <exception cref="T:System.ArgumentNullException">source must not be <c>null</c>.</exception>
/// <exception cref="T:System.ArgumentNullException">handler must not be <c>null</c>.</exception>
protected void RemoveWeakEventListener(INotifyCollectionChanged source,
NotifyCollectionChangedEventHandler handler)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
CollectionChangedEventListener changedEventListener = collectionChangedListeners.LastOrDefault(l =>
{
if (l.Source == source)
{
return(l.Handler == handler);
}
return(false);
});
if (changedEventListener == null)
{
return;
}
collectionChangedListeners.Remove(changedEventListener);
CollectionChangedEventManager.RemoveListener(source, changedEventListener);
}
/// <summary>
/// Handles a change to the Columns property.
/// </summary>
/// <param name="dependencyObject">The DependancyObject that owns the property.</param>
/// <param name="dependencyPropertyChangedEventArgs">The DependencyProperty that has changed.</param>
static void OnColumnsPropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
// The listener is the object that owns the Columns property.
ColumnViewRowPresenterBase columnViewRowPresenterBase = dependencyObject as ColumnViewRowPresenterBase;
// This will disconnect the old listener from getting changes to the columns.
ColumnViewColumnCollection oldCollection = dependencyPropertyChangedEventArgs.OldValue as ColumnViewColumnCollection;
if (oldCollection != null)
{
// This will disconnect the RowPresenter from changes made to the old column collection.
CollectionChangedEventManager.RemoveListener(oldCollection, columnViewRowPresenterBase);
// This will clear out any items from the old collection. This is preferrable to a collection 'Reset' because we can provide the columns that have
// gone out of scope which might not be available any other way.
columnViewRowPresenterBase.OnColumnCollectionChanged(
columnViewRowPresenterBase,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldCollection));
}
// This will connect the new listener to get changes to the columns.
ColumnViewColumnCollection newCollection = dependencyPropertyChangedEventArgs.NewValue as ColumnViewColumnCollection;
if (newCollection != null)
{
// This will connect the RowPresenter to the collection of columns so that any changes made to the column set is reflected in the arrangement of
// cells in the view.
CollectionChangedEventManager.AddListener(newCollection, columnViewRowPresenterBase);
// This will syncrhonize the view to the new column set.
columnViewRowPresenterBase.OnColumnCollectionChanged(
columnViewRowPresenterBase,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newCollection));
}
}
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
{
base.OnItemsSourceChanged(oldValue, newValue);
var oldCollection = oldValue as INotifyCollectionChanged;
var newCollection = newValue as INotifyCollectionChanged;
if (oldCollection != null)
{
CollectionChangedEventManager.RemoveListener(oldCollection, this);
}
if (newCollection != null)
{
CollectionChangedEventManager.AddListener(newCollection, this);
}
if (!this.IsInitialized)
{
return;
}
if (!VirtualizingStackPanel.GetIsVirtualizing(this) ||
(VirtualizingStackPanel.GetIsVirtualizing(this) && (newValue != null)))
{
this.RemoveUnavailableSelectedItems();
}
this.UpdateSelectedMemberPathValuesBindings();
this.UpdateValueMemberPathValuesBindings();
}
private static void OnErrorsProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var node = (ErrorNode)d.GetValue(Scope.ErrorsProperty);
if (node == null)
{
// this happens when disposing
return;
}
var oldValue = (ReadOnlyObservableCollection <ValidationError>)e.OldValue;
if (oldValue != null)
{
CollectionChangedEventManager.RemoveListener(oldValue, node);
}
var newValue = (ReadOnlyObservableCollection <ValidationError>)e.NewValue;
if (newValue != null)
{
CollectionChangedEventManager.AddListener(newValue, node);
}
node.RefreshErrors();
BubbleRoute.Notify(node);
}
internal void ReleaseEvents()
{
if (_innerListListener is not null)
{
CollectionChangedEventManager.RemoveListener((INotifyCollectionChanged)_innerList, _innerListListener);
_innerListListener = null;
}
}
protected void StopListeningForChangeEvents(IList list)
{
if (!(list is INotifyCollectionChanged))
{
return;
}
CollectionChangedEventManager.RemoveListener(list as INotifyCollectionChanged, (IWeakEventListener)this);
}
protected override void RemoveItem(int index)
{
if (this[index] is INotifyCollectionChanged observablePolygon)
{
CollectionChangedEventManager.RemoveListener(observablePolygon, this);
}
base.RemoveItem(index);
}
protected override void ClearItems()
{
foreach (var observablePolygon in this.OfType <INotifyCollectionChanged>())
{
CollectionChangedEventManager.RemoveListener(observablePolygon, this);
}
base.ClearItems();
}
/// <summary>
/// Stops listening for change events.
/// </summary>
/// <param name="list">The list to stop listening to.</param>
protected void StopListeningForChangeEvents(IList list)
{
var source = list as INotifyCollectionChanged;
if (source != null)
{
CollectionChangedEventManager.RemoveListener(source, this);
}
}
/// <inheritdoc />
protected override void RemoveItem(int index)
{
WallpaperCategory category = this[index];
base.RemoveItem(index);
CollectionChangedEventManager.RemoveListener(category, this);
this.OnPropertyChanged("AllWallpapersCount");
}
protected override void SetItem(int index, IEnumerable <Location> polygon)
{
if (this[index] is INotifyCollectionChanged observablePolygon)
{
CollectionChangedEventManager.RemoveListener(observablePolygon, this);
}
base.SetItem(index, polygon);
}
private void UnregisterCollectionChanged(INotifyCollectionChanged collection)
{
if (collection == null)
{
return;
}
CollectionChangedEventManager.RemoveListener(collection, this);
}
private void Unsubscribe(ICollection collection)
{
var notifierCollection = collection as INotifyCollectionChanged;
if (notifierCollection != null)
{
CollectionChangedEventManager.RemoveListener(notifierCollection, this);
}
}
/// <summary>
/// Stops listening for change events.
/// </summary>
/// <param name="list">The list to stop listening to.</param>
protected void StopListeningForChangeEvents(IList list)
{
var notifyingList = list as INotifyCollectionChanged;
if (list != null)
{
CollectionChangedEventManager.RemoveListener(notifyingList, this);
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
INotifyCollectionChanged source = GetSource();
if (source != null)
{
CollectionChangedEventManager.RemoveListener(source, this);
}
CollectionChanged = null;
}
protected void UnlinkVirtualListAndCollectionViewGroup(VirtualList virtualList)
{
DataGridVirtualizingCollectionViewGroupBase collectionViewGroup = null;
if (m_virtualListVSCollectionViewGroupDictionary.TryGetValue(virtualList, out collectionViewGroup))
{
CollectionChangedEventManager.RemoveListener(virtualList, collectionViewGroup);
m_virtualListVSCollectionViewGroupDictionary.Remove(virtualList);
}
}
protected override void RemoveItem(int index)
{
var observablePolygon = this[index] as INotifyCollectionChanged;
if (observablePolygon != null)
{
CollectionChangedEventManager.RemoveListener(observablePolygon, this);
}
base.RemoveItem(index);
}
internal void UnregisterAllAutoFilterValuesChangedEvent()
{
foreach (INotifyCollectionChanged autoFilterValues in m_registeredAutoFilterValuesToFieldNames.Keys)
{
CollectionChangedEventManager.RemoveListener(autoFilterValues, this);
}
m_registeredAutoFilterValuesToFieldNames.Clear();
m_registeredFieldNamesToAutoFilterValues.Clear();
this.DetailDescriptionAutoFilterValuesChanged = null;
}
private void UnAdoptSourceCollection()
{
var notifyChangedCollection = this.sourceCollection as INotifyCollectionChanged;
if (notifyChangedCollection != null)
{
CollectionChangedEventManager.RemoveListener(notifyChangedCollection, this);
}
this.sourceCollection = null;
}