public static IObservable <ItemAdded <T> > ObserveAddedWithIndex <T>(this IActiveList <T> list)
{
var subject = new Subject <ItemAdded <T> >();
var handler = new EventHandler <NotifyCollectionChangedEventArgs>((o, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Replace:
subject.OnNext(new ItemAdded <T>((T)e.NewItems[0], e.NewStartingIndex));
break;
case NotifyCollectionChangedAction.Reset:
for (int i = 0; i < list.Count; ++i)
{
subject.OnNext(new ItemAdded <T>(list[i], i));
}
break;
}
});
CollectionChangedEventManager.AddHandler(list, handler);
subject.Subscribe(_ => { }, () => CollectionChangedEventManager.RemoveHandler(list, handler));
return(subject);
}
public ProfileOptionsActionsPage(ProfileOptions profile)
{
_profile = profile;
Pages = profile.Actions;
SyncPagesWithActionCollection(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, profile.Actions));
CollectionChangedEventManager.AddHandler(profile.Actions, SyncPagesWithActionCollection);
}
public ItemCountSynchronizer(INavigationNode node, EmailFolder folder)
{
this.node = node;
this.folder = folder;
CollectionChangedEventManager.AddHandler(folder.Emails, EmailsCollectionChanged);
UpdateItemCount();
}
/// <summary>
/// コレクションの依存関係プロパティ変更イベントハンドラです。
/// </summary>
/// <param name="d">イベント発行元</param>
/// <param name="e">イベント引数</param>
private static void OnCollectionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var colorMap = d as ColorMap;
if (e.OldValue != null)
{
if (e.OldValue is INotifyCollectionChanged)
{
#if NET4
(e.OldValue as INotifyCollectionChanged).CollectionChanged -= colorMap.OnCollectionChanged;
#else
CollectionChangedEventManager.RemoveHandler(e.OldValue as INotifyCollectionChanged, colorMap.OnCollectionChanged);
#endif
}
}
if (e.NewValue != null)
{
if (e.NewValue is INotifyCollectionChanged)
{
#if NET4
(e.OldValue as INotifyCollectionChanged).CollectionChanged += colorMap.OnCollectionChanged;
#else
CollectionChangedEventManager.AddHandler(e.NewValue as INotifyCollectionChanged, colorMap.OnCollectionChanged);
#endif
}
}
colorMap.UpdateRendering_GraphBitmap();
}
/// <summary>Listens to CollectionChanged events and and invokes a callback.
/// The benefit is a weak subscription that keeps a strong reference while the subscriber is alive.</summary>
protected void ForwardCollectionEvents(INotifyCollectionChanged source, Action notifyHandler)
{
EventHandler <NotifyCollectionChangedEventArgs> func = (sender, e) => notifyHandler();
funcReferences.Add(func);
CollectionChangedEventManager.AddHandler(source, func);
}
private void RegisterEventHandlers(IDockControl dataContext)
{
if (dataContext == null)
{
return;
}
// Attach to IDockControl.
if (dataContext.DockStrategy == null)
{
throw new DockException("IDockControl.DockStrategy must not be null.");
}
DockStrategy = dataContext.DockStrategy;
// Observe IDockControl properties.
PropertyChangedEventManager.AddHandler(dataContext, OnDockStrategyChanged, nameof(IDockControl.DockStrategy));
PropertyChangedEventManager.AddHandler(dataContext, OnActiveItemChanged, nameof(IDockControl.ActiveDockTabItem));
//PropertyChangedEventManager.AddHandler(dataContext, OnActivePaneChanged, nameof(IDockControl.ActiveDockTabPane));
// The ICollectionView is used to filter IFloatWindows.
var collectionView = CollectionViewSource.GetDefaultView(dataContext.FloatWindows);
var collectionViewLiveShaping = collectionView as ICollectionViewLiveShaping;
if (collectionViewLiveShaping != null && collectionViewLiveShaping.CanChangeLiveFiltering)
{
collectionViewLiveShaping.LiveFilteringProperties.Clear();
collectionViewLiveShaping.LiveFilteringProperties.Add(nameof(IFloatWindow.IsVisible));
collectionViewLiveShaping.IsLiveFiltering = true;
collectionView.Filter = floatWindow => ((IFloatWindow)floatWindow).IsVisible;
}
CollectionChangedEventManager.AddHandler(collectionView, OnFloatWindowsChanged);
}
public TrackAffiliationData(SelectionProperties context, TrackViewModel track)
{
this.context = context;
_track = track;
CollectionChangedEventManager.AddHandler(track.Blocks, (sender, e) => Notify(nameof(AffiliationState)));
}
public PropertyChangedListener(ObservableCollection <T> collection, string propertyName = "")
{
_collection = collection;
_propertyName = propertyName ?? "";
AddRange(collection);
CollectionChangedEventManager.AddHandler(collection, CollectionChanged);
}
public PropertyChangedListener(ObservableCollection <T> collection, string propertyName = "")
{
this.collection = collection;
this.propertyName = propertyName ?? string.Empty;
this.AddRange(collection);
CollectionChangedEventManager.AddHandler(collection, this.CollectionChanged);
}
private static void OnSourceErrorsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var node = Scope.GetNode(d) as InputNode;
if (node == null)
{
// this happens when disposing
return;
}
var oldErrors = (ReadOnlyObservableCollection <ValidationError>)e.OldValue;
if (ShouldTrack(oldErrors))
{
CollectionChangedEventManager.RemoveHandler(oldErrors, node.OnSourceErrorsChanged);
}
var newErrors = (ReadOnlyObservableCollection <ValidationError>)e.NewValue;
node.ErrorCollection.Remove(oldErrors);
node.ErrorCollection.Add(newErrors);
if (ShouldTrack(newErrors))
{
CollectionChangedEventManager.AddHandler(newErrors, node.OnSourceErrorsChanged);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SynchronizingCollection<T, TOriginal>"/> class.
/// </summary>
/// <param name="originalCollection">The original collection.</param>
/// <param name="factory">The factory which is used to create new elements in this collection.</param>
/// <exception cref="ArgumentNullException">The argument originalCollection must not be null.</exception>
/// <exception cref="ArgumentNullException">The argument factory must not be null.</exception>
public SynchronizingCollection(IEnumerable <TOriginal> originalCollection, Func <TOriginal, T> factory)
: base(new ObservableCollection <T>())
{
if (originalCollection == null)
{
throw new ArgumentNullException("originalCollection");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
mapping = new List <Tuple <TOriginal, T> >();
this.originalCollection = originalCollection;
this.factory = factory;
itemComparer = EqualityComparer <T> .Default;
originalItemComparer = EqualityComparer <TOriginal> .Default;
INotifyCollectionChanged collectionChanged = originalCollection as INotifyCollectionChanged;
if (collectionChanged != null)
{
CollectionChangedEventManager.AddHandler(collectionChanged, OriginalCollectionChanged);
}
innerCollection = (ObservableCollection <T>)Items;
foreach (TOriginal item in originalCollection)
{
innerCollection.Add(CreateItem(item));
}
}
/// <summary> Initializes a new instance of the <see cref="SynchronizingCollection<T, TOriginal>"/> class. </summary>
/// <param name="_originalCollection">The original collection.</param>
/// <param name="_factory">The factory which is used to create new elements in this collection.</param>
/// <exception cref="ArgumentNullException">The argument originalCollection must not be null.</exception>
/// <exception cref="ArgumentNullException">The argument factory must not be null.</exception>
public SynchronizingCollection(IEnumerable <TOriginal> _originalCollection, Func <TOriginal, T> _factory)
: base(new ObservableCollection <T>())
{
if (null == _originalCollection)
{
throw new ArgumentNullException(nameof(_originalCollection));
}
if (null == _factory)
{
throw new ArgumentNullException(nameof(_factory));
}
m_Mapping = new List <Tuple <TOriginal, T> >();
m_OriginalCollection = _originalCollection;
m_Factory = _factory;
m_ItemComparer = EqualityComparer <T> .Default;
m_OriginalItemComparer = EqualityComparer <TOriginal> .Default;
INotifyCollectionChanged collectionChanged = _originalCollection as INotifyCollectionChanged;
if (null != collectionChanged)
{
CollectionChangedEventManager.AddHandler(collectionChanged, OriginalCollectionChanged);
}
m_InnerCollection = (ObservableCollection <T>) this.Items;
foreach (TOriginal _item in _originalCollection)
{
m_InnerCollection.Add(CreateItem(_item));
}
}
private static void AutoScrollPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
{
var scroller = obj as ScrollViewer;
if (scroller == null || args.OldValue == args.NewValue)
{
return;
}
if (args.OldValue != null)
{
var coll = (INotifyCollectionChanged)args.OldValue;
CollectionChangedEventManager.RemoveHandler(coll, AutoScrollSource_CollectionChanged);
WeakEventManager <ScrollViewer, SizeChangedEventArgs> .RemoveHandler(scroller, "SizeChanged", ScrollViewer_SizeChanged);
WeakPair pair = Get(coll, (p, _, __) => p);
if (pair != null)
{
_pairs.Remove(pair);
}
}
if (args.NewValue != null)
{
var coll = (INotifyCollectionChanged)args.NewValue;
CollectionChangedEventManager.AddHandler(coll, AutoScrollSource_CollectionChanged);
WeakEventManager <ScrollViewer, SizeChangedEventArgs> .AddHandler(scroller, "SizeChanged", ScrollViewer_SizeChanged);
AddPair(coll, scroller);
}
}
private ViewModelCollection(IList <TModel> models, Func <TModel, TViewModel> viewModelFactory)
{
CollectionChangedEventManager.AddHandler((INotifyCollectionChanged)models, SourceCollectionChanged);
m_models = models;
m_viewModelFactory = viewModelFactory;
m_viewModelMap = new ConditionalWeakTable <TModel, TViewModel>();
m_viewModels = new List <TViewModel>(models.Select(m => GetOrCreateVM(m)));
}
private void ListenToCollectionChanges()
{
Debug.Assert(m_vector != null);
if (m_vector is INotifyCollectionChanged incc)
{
CollectionChangedEventManager.AddHandler(incc, OnCollectionChanged);
}
}
private object InitializeTranscodingListView()
{
TranscodingListViewModel.TranscodingManager = transcodingManager;
TranscodingListViewModel.InsertFilesAction = InsertFiles;
TranscodingListViewModel.InsertMusicFilesAction = InsertMusicFiles;
CollectionChangedEventManager.AddHandler((INotifyCollectionChanged)TranscodingListViewModel.SelectedTranscodeItems, SelectedTranscodeItemsCollectionChanged);
return(TranscodingListViewModel.View);
}
// Token: 0x06001B48 RID: 6984 RVA: 0x00080651 File Offset: 0x0007E851
private void AddCollectionContainer(CollectionContainer cc)
{
if (this.InternalList.Contains(cc))
{
throw new ArgumentException(SR.Get("CollectionContainerMustBeUniqueForComposite"), "cc");
}
CollectionChangedEventManager.AddHandler(cc, new EventHandler <NotifyCollectionChangedEventArgs>(this.OnContainedCollectionChanged));
}
public DataSourceViewModel(Session session, DataSource model)
: base(session)
{
Model = model;
CollectionChangedEventManager.AddHandler(Model.Figures, OnFiguresChanged);
OnFiguresChanged(null, null);
}
/// <summary>Initializes a new instance of the ObservableListView class that represents a view of the specified list.</summary>
/// <param name="originalList">The original list.</param>
/// <param name="comparer">Optional, a custom comparer used to compare the items.</param>
/// <param name="filter">Optional, a filter used for this list view.</param>
/// <param name="sort">Optional, a sorting used for this list view.</param>
/// <exception cref="ArgumentNullException">The argument originalCollection must not be null.</exception>
public ObservableListView(IEnumerable <T> originalList, IEqualityComparer <T>?comparer, Predicate <T>?filter,
Func <IEnumerable <T>, IOrderedEnumerable <T> >?sort) : base(originalList, comparer, filter, sort, true)
{
originalObservableCollection = originalList as INotifyCollectionChanged;
if (originalObservableCollection != null)
{
CollectionChangedEventManager.AddHandler(originalObservableCollection, OriginalCollectionChanged);
}
}
/// <summary>Initializes a new instance of the <see cref="SynchronizingCollection{T, TOriginal}"/> class.</summary>
/// <param name="originalCollection">The original collection.</param>
/// <param name="factory">The factory which is used to create new elements in this collection.</param>
/// <exception cref="ArgumentNullException">The argument originalCollection must not be null.</exception>
/// <exception cref="ArgumentNullException">The argument factory must not be null.</exception>
public SynchronizingCollection(IEnumerable <TOriginal> originalCollection, Func <TOriginal, T> factory)
: base(originalCollection, factory, true)
{
originalObservableCollection = originalCollection as INotifyCollectionChanged;
if (originalObservableCollection != null)
{
CollectionChangedEventManager.AddHandler(originalObservableCollection, OriginalCollectionChanged);
}
}
private void RegisterChangeHandler()
{
if (myChildObservationCount == 0)
{
CollectionChangedEventManager.AddHandler(Children, OnChildrenChanged);
}
myChildObservationCount++;
}
protected DocumentController(IFileService fileService)
{
if (fileService == null)
{
throw new ArgumentNullException(nameof(fileService));
}
this.fileService = fileService;
PropertyChangedEventManager.AddHandler(fileService, FileServicePropertyChanged, "");
CollectionChangedEventManager.AddHandler(fileService.Documents, DocumentsCollectionChanged);
}
public MainViewModel(IMainView view, IShellService shellService, IFileService fileService)
: base(view)
{
this.shellService = shellService;
FileService = fileService;
DocumentViews = new ObservableCollection <object>();
CollectionChangedEventManager.AddHandler(DocumentViews, DocumentViewsCollectionChanged);
PropertyChangedEventManager.AddHandler(fileService, FileServicePropertyChanged, "");
}
public MainViewModel()
{
if (Dal == null)
{
return;
}
CollectionChangedEventManager.AddHandler(Dal.TraceLog, TraceLog_CollectionChanged);
TraceLogString = new StringBuilder();
}
public static IObservable <ItemRemoved <T> > ObserveRemovedWithIndex <T>(this IActiveList <T> list)
{
var subject = new Subject <ItemRemoved <T> >();
var copy = new List <T>(list.Count + 8);
foreach (var item in list)
{
copy.Add(item);
}
var handler = new EventHandler <NotifyCollectionChangedEventArgs>((o, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
copy.Insert(e.NewStartingIndex, (T)e.NewItems[0]);
break;
case NotifyCollectionChangedAction.Remove:
copy.RemoveAt(e.OldStartingIndex);
subject.OnNext(new ItemRemoved <T>((T)e.OldItems[0], e.OldStartingIndex));
break;
case NotifyCollectionChangedAction.Replace:
copy[e.NewStartingIndex] = (T)e.NewItems[0];
subject.OnNext(new ItemRemoved <T>((T)e.OldItems[0], e.OldStartingIndex));
break;
case NotifyCollectionChangedAction.Move:
copy.RemoveAt(e.OldStartingIndex);
copy.Insert(e.NewStartingIndex, (T)e.NewItems[0]);
break;
case NotifyCollectionChangedAction.Reset:
for (int i = copy.Count - 1; i >= 0; --i)
{
subject.OnNext(new ItemRemoved <T>(copy[i], i));
}
copy.Clear();
foreach (var item in list)
{
copy.Add(item);
}
break;
}
});
CollectionChangedEventManager.AddHandler(list, handler);
subject.Subscribe(_ => { }, () => CollectionChangedEventManager.RemoveHandler(list, handler));
return(subject);
}
private void OnRootChanged()
{
myTree.StateContainer.DataContext = Root;
if (Root != null)
{
CollectionChangedEventManager.AddHandler((INotifyCollectionChanged)Root.Children, OnRootChildrenChanged);
myTree.StateContainer.GetRoot().ShowChildrenCount = ShowChildrenCount;
}
}
private void OnProjectChanged()
{
if (myProjectHost.Project == null)
{
return;
}
CollectionChangedEventManager.AddHandler(myLutService.CurrenciesLut.Currencies, OnCurrenciesChanged);
RaisePropertyChanged(nameof(CurrenciesLut));
RaisePropertyChanged(nameof(Currencies));
}
public ListToReadOnlyWrapper(IList <T> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
_source = source;
if (_source is INotifyCollectionChanged)
{
CollectionChangedEventManager.AddHandler(_source as INotifyCollectionChanged, HandleCollectionChanged);
}
}
// Hook up to a newly-added CollectionContainer
private void AddCollectionContainer(CollectionContainer cc)
{
if (InternalList.Contains(cc))
{
throw new ArgumentException(SR.Get(SRID.CollectionContainerMustBeUniqueForComposite), "cc");
}
CollectionChangedEventManager.AddHandler(cc, OnContainedCollectionChanged);
#if DEBUG
_hasRepeatedCollectionIsValid = false;
#endif
}
/// <summary>Listens to CollectionChanged events and notifies a list of other properties.</summary>
protected void ForwardCollectionEvents(INotifyCollectionChanged source, params string[] notifyPropertyNames)
{
EventHandler <NotifyCollectionChangedEventArgs> func = (sender, e) =>
{
foreach (string p in notifyPropertyNames)
{
Notify(p);
}
};
funcReferences.Add(func);
CollectionChangedEventManager.AddHandler(source, func);
}