/// <summary> /// Låter andra klasser lyssna på förändringar i repositoryt så att de kan uppdateras. /// </summary> /// <param name="handler"></param> /// <returns>Referns till en instans av FDRFeedRepository med eventhanterare</returns> public static IRepository<Feed> getFeeds(NotifyCollectionChangedEventHandler handler) { if (feeds == null) feeds = new FDRFeedRepository(); feeds.CollectionChanged += handler; return feeds; }
public void AddHandler(NotifyCollectionChangedEventHandler handler) { if(handler != null) { _books.CollectionChanged += handler; } }
public ItemsSourceCollectionViewSource([NotNull] UICollectionView collectionView, string itemTemplate = AttachedMemberConstants.ItemTemplate) : base(collectionView, itemTemplate) { _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3)); }
public GeneratorNodeFactory( NotifyCollectionChangedEventHandler itemsChangedHandler, NotifyCollectionChangedEventHandler groupsChangedHandler, EventHandler<ExpansionStateChangedEventArgs> expansionStateChangedHandler, EventHandler isExpandedChangingHandler, EventHandler isExpandedChangedHandler, DataGridControl dataGridControl ) { if( itemsChangedHandler == null ) throw new ArgumentNullException( "itemsChangedHandler" ); if( groupsChangedHandler == null ) throw new ArgumentNullException( "groupsChangedHandler" ); if( expansionStateChangedHandler == null ) throw new ArgumentNullException( "expansionStateChangedHandler" ); if( isExpandedChangingHandler == null ) throw new ArgumentNullException( "isExpandedChangingHandler" ); if( isExpandedChangedHandler == null ) throw new ArgumentNullException( "isExpandedChangedHandler" ); m_itemsChangedHandler = itemsChangedHandler; m_groupsChangedHandler = groupsChangedHandler; m_expansionStateChangedHandler = expansionStateChangedHandler; m_isExpandedChangingHandler = isExpandedChangingHandler; m_isExpandedChangedHandler = isExpandedChangedHandler; if( dataGridControl != null ) { m_dataGridControl = new WeakReference( dataGridControl ); } }
public CollectionChangedEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler) { if (source == null) { throw new ArgumentNullException("source"); } if (handler == null) { throw new ArgumentNullException("handler"); } this.source = source; this.handler = handler; }
/// <summary> /// Låter andra klasser lyssna på förändringar i repositoryt så att de kan uppdateras. /// </summary> /// <param name="handler"></param> /// <returns>Referns till en instans av FDRCategoryRepository med eventhanterare</returns> public static IRepository<Category> getCategories(NotifyCollectionChangedEventHandler handler) { if (categories == null) categories = new FDRCategoryRepository(); categories.CollectionChanged += handler; return categories; }
public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e) { var ctrl = s as ItemsControl; if (ctrl == null) throw new InvalidOperationException("This attached property only supports ItemsControl or derived types."); var data = ctrl.Items as INotifyCollectionChanged; if (data == null) throw new InvalidOperationException("Collection does not support change notifications."); Control parentCtrl = ctrl; while (parentCtrl != null && parentCtrl.GetType() != typeof(ScrollViewer)) parentCtrl = parentCtrl.Parent as Control; ScrollViewer sv = parentCtrl as ScrollViewer; var scrollToEndHandler = new NotifyCollectionChangedEventHandler( (s1, e1) => { if (e1.Action == NotifyCollectionChangedAction.Add && sv != null) sv.ScrollToBottom(); }); if ((bool)e.NewValue) data.CollectionChanged += scrollToEndHandler; else data.CollectionChanged -= scrollToEndHandler; }
public static void OnAutoScrollChanged(DependencyObject s, DependencyPropertyChangedEventArgs e) { var val = (bool)e.NewValue; var lb = s as ListView; if (lb == null) throw new InvalidOperationException("This behavior can only be attached to a ListView."); var ic = lb.Items; var data = ic.SourceCollection as INotifyCollectionChanged; if (data == null) return; var autoscroller = new NotifyCollectionChangedEventHandler( (s1, e1) => { var selectedItem = default(object); switch (e1.Action) { case NotifyCollectionChangedAction.Add: case NotifyCollectionChangedAction.Move: selectedItem = e1.NewItems[e1.NewItems.Count - 1]; break; case NotifyCollectionChangedAction.Remove: if (ic.Count < e1.OldStartingIndex) { selectedItem = ic[e1.OldStartingIndex - 1]; } else if (ic.Count > 0) selectedItem = ic[0]; break; case NotifyCollectionChangedAction.Reset: if (ic.Count > 0) selectedItem = ic[0]; break; } if (selectedItem == default(object)) return; ic.MoveCurrentTo(selectedItem); lb.ScrollIntoView(selectedItem); }); if (val) data.CollectionChanged += autoscroller; else data.CollectionChanged -= autoscroller; }
public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e) { var listBox = s as ListBox; if(listBox==null) return; var listBoxItems = listBox.Items; var data = listBoxItems.SourceCollection as INotifyCollectionChanged; if (data == null) return; var scrollToEndHandler = new NotifyCollectionChangedEventHandler( (s1, e1) => { if (listBox.Items.Count <= 0) return; var lastItem = listBox.Items[listBox.Items.Count - 1]; listBoxItems.MoveCurrentTo(lastItem); listBox.ScrollIntoView(lastItem); }); if ((bool)e.NewValue) data.CollectionChanged += scrollToEndHandler; else data.CollectionChanged -= scrollToEndHandler; }
public MvvmPickerViewModel([NotNull] UIPickerView pickerView) { Should.NotBeNull(pickerView, "pickerView"); _pickerView = ServiceProvider.WeakReferenceFactory(pickerView); _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3)); EmptyTitle = "-"; }
/// <summary> /// Hookups the handler to the collection changed event. When the value changes it removes the handler. /// </summary> /// <param name="oldValue">The old collection.</param> /// <param name="newValue">The new collection.</param> /// <param name="handler">The handler to hookup.</param> public static void HookupToCollectionChanged(INotifyCollectionChanged oldValue, INotifyCollectionChanged newValue, NotifyCollectionChangedEventHandler handler) { if (oldValue != null) oldValue.CollectionChanged -= handler; if (newValue != null) newValue.CollectionChanged += handler; }
public EventTracker(IVisualElementRenderer renderer) { if (renderer == null) throw new ArgumentNullException("renderer"); _collectionChangedHandler = ModelGestureRecognizersOnCollectionChanged; _renderer = renderer; _renderer.ElementChanged += OnElementChanged; }
public PropertiesWindowViewModel(PropertiesWindow propertiesWindow) { this.propertiesWindow = propertiesWindow; onSelectionChanged = (sender, args) => { SelectionChanged(sender, args); }; Items = new ObservableCollection<PropertySingleItem>(); }
private static void Subscribe(DataGrid dataGrid) { var handler = new NotifyCollectionChangedEventHandler((sender, eventArgs) => ScrollToEnd(dataGrid)); if (handlersDict.ContainsKey(dataGrid)) { return; } handlersDict.Add(dataGrid, handler); ((INotifyCollectionChanged)dataGrid.Items).CollectionChanged += handler; ScrollToEnd(dataGrid); }
/// <summary> /// Adds a 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="ArgumentNullException">source must not be <c>null</c>.</exception> /// <exception cref="ArgumentNullException">handler must not be <c>null</c>.</exception> protected void AddWeakEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler) { if (source == null) { throw new ArgumentNullException("source"); } if (handler == null) { throw new ArgumentNullException("handler"); } CollectionChangedEventListener listener = new CollectionChangedEventListener(source, handler); collectionChangedListeners.Add(listener); CollectionChangedEventManager.AddListener(source, listener); }
private static void SetupOnUnloadedHandler(DependencyObject dependencyObject, INotifyCollectionChanged observableCollection, NotifyCollectionChangedEventHandler sourceChangedHandler) { RoutedEventHandler unloadedEventHandler = null; unloadedEventHandler = (sender, args) => { observableCollection.CollectionChanged -= sourceChangedHandler; ((ListViewBase)sender).SelectionChanged -= OnGridSelectionChanged; ((ListViewBase)sender).Unloaded -= unloadedEventHandler; }; ((ListViewBase)dependencyObject).Unloaded += unloadedEventHandler; }
public override void Dispose() { if (IsDisposed) return; foreach (var kvp in myObservedCollections) kvp.Value (); myObservedCollections.Clear(); myObservedCollections = null; myCollectionChangedEventHandler = null; base.Dispose (); }
protected void RemoveEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler) { if (source == null) { throw new ArgumentException("source"); } if (handler == null) { throw new ArgumentException("handler"); } CollectionChangedEventListener listener = collectionEventListeners.LastOrDefault(c => c.Source == source && c.Handler == handler); if (listener != null) { collectionEventListeners.Remove(listener); CollectionChangedEventManager.RemoveListener(source, listener); } }
public DataMappingViewModel(IWebActivity activity, NotifyCollectionChangedEventHandler mappingCollectionChangedEventHandler = null) { _activity = activity; _actionManager = new ActionManager(); Inputs = new ObservableCollection<IInputOutputViewModel>(); Outputs = new ObservableCollection<IInputOutputViewModel>(); if(mappingCollectionChangedEventHandler != null) { Inputs.CollectionChanged += mappingCollectionChangedEventHandler; Outputs.CollectionChanged += mappingCollectionChangedEventHandler; } Initialize(_activity); }
public ItemsSourcePagerAdapter([NotNull] ViewPager viewPager) { Should.NotBeNull(viewPager, nameof(viewPager)); _viewPager = viewPager; _fragmentManager = viewPager.GetFragmentManager(); _itemTemplateProvider = new DataTemplateProvider(viewPager, AttachedMemberConstants.ItemTemplate, AttachedMemberConstants.ItemTemplateSelector); _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3)); var activityView = _viewPager.Context.GetActivity() as IActivityView; if (activityView != null) { _listener = ReflectionExtensions.CreateWeakEventHandler<ItemsSourcePagerAdapter, EventArgs>(this, (adapter, o, arg3) => adapter.ActivityViewOnDestroyed((Activity)o)); activityView.Mediator.Destroyed += _listener.Handle; } }
private static void Subscribe(DataGrid dataGrid) { if (infoDict.ContainsKey(dataGrid)) return; var timer = new DispatcherTimer(DispatcherPriority.Background); var handler = new NotifyCollectionChangedEventHandler((sender, eventArgs) => timer.Start()); infoDict.Add(dataGrid, new DataGridInfo(handler, timer)); timer.Tick += (sender, args) => ScrollToEnd(dataGrid); ((INotifyCollectionChanged)dataGrid.Items).CollectionChanged += handler; timer.Start(); }
internal void HandleToolCollectionNotification(NotifyCollectionChangedEventHandler listener, bool register) { if (null == listener) { throw FxTrace.Exception.ArgumentNull("listener"); } if (register) { this.tools.CollectionChanged += listener; } else { this.tools.CollectionChanged -= listener; } }
/// <summary> /// Initializes a new instance of the <see cref="ItemsSourceAdapter" /> class. /// </summary> public ItemsSourceRecyclerAdapter([NotNull] global::Android.Support.V7.Widget.RecyclerView recyclerView) { Should.NotBeNull(recyclerView, "recyclerView"); _recyclerView = recyclerView; _itemTemplateProvider = new DataTemplateProvider(_recyclerView, AttachedMemberConstants.ItemTemplate, AttachedMemberConstants.ItemTemplateSelector); _layoutInflater = _recyclerView.Context.GetBindableLayoutInflater(); _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3)); var activityView = _recyclerView.Context.GetActivity() as IActivityView; if (activityView != null) { _listener = ReflectionExtensions.CreateWeakEventHandler<ItemsSourceRecyclerAdapter, EventArgs>(this, (adapter, o, arg3) => adapter.ActivityViewOnDestroyed((Activity)o)); activityView.Mediator.Destroyed += _listener.Handle; } }
/// <summary> /// This method will be called when the AutoScrollToEnd /// property was changed /// </summary> /// <param name="s">The sender (the ListBox)</param> /// <param name="e">Some additional information</param> public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e) { var listView = s as ListView; if (listView != null) { var listViewItems = listView.Items; var data = listViewItems.SourceCollection as INotifyCollectionChanged; var scrollToEndHandler = new NotifyCollectionChangedEventHandler( (s1, e1) => { if (listView.Items.Count > 0 && e1 != null && e1.NewItems != null) // fix for error in certain conditions { //object lastItem = listView.Items[listView.Items.Count - 1]; var lastItem = e1.NewItems[0]; listView.Items.MoveCurrentTo(lastItem); listView.ScrollIntoView(lastItem); listView.SelectedItem = lastItem; } }); var gotFocusHandler = new RoutedEventHandler ( (s2, e2) => { if (listView.Items.Count > 0) { //object lastItem = listView.Items[listView.Items.Count - 1]; listView.ScrollIntoView(listView.SelectedItem); } }); if ((bool)e.NewValue) { if (data != null) { data.CollectionChanged += scrollToEndHandler; listView.GotFocus += gotFocusHandler; } } else if (data != null) { data.CollectionChanged -= scrollToEndHandler; listView.GotFocus -= gotFocusHandler; } } }
public void Advertisements_WhenNewItemAdded_CallsCollectionChangedEvent() { // Arrange var paperVm = GetValidNewspaperItemViewModel(); var adVm = GetValidAdvertisementItemViewModel(); IList addedItems = new ArrayList(); var collectionChangedEvent = new NotifyCollectionChangedEventHandler((sender, arg) => { addedItems = arg.NewItems; }); paperVm.Advertisements.CollectionChanged += collectionChangedEvent; // Act paperVm.Advertisements.Add(adVm); // Assert addedItems.Count.Should().Be(1, "One item was added"); adVm.Should().Be(addedItems[0]); }
public static void OnIsAutoScrollChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e) { var value = (bool)e.NewValue; var listView = obj as ListView; var itemCollection = listView.Items; var data = (INotifyCollectionChanged)itemCollection; var autoscroller = new NotifyCollectionChangedEventHandler( (o, arg) => { var selectedItem = default(object); switch (arg.Action) { case NotifyCollectionChangedAction.Add: case NotifyCollectionChangedAction.Move: { selectedItem = arg.NewItems[arg.NewItems.Count - 1]; break; } case NotifyCollectionChangedAction.Remove: { if (itemCollection.Count < arg.OldStartingIndex) { selectedItem = itemCollection[arg.OldStartingIndex - 1]; } else if (itemCollection.Count > 0) selectedItem = itemCollection[0]; break; } case NotifyCollectionChangedAction.Reset: { if (itemCollection.Count > 0) selectedItem = itemCollection[0]; break; } } if (selectedItem != default(object)) { itemCollection.MoveCurrentTo(selectedItem); listView.ScrollIntoView(selectedItem); } }); if (value) data.CollectionChanged += autoscroller; else data.CollectionChanged -= autoscroller; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// private static void AssertChange( ObservableCollection<int> original, Action<ObservableCollection<int>> change, ICollection copy, NotifyCollectionChangedEventHandler handler) { try { change(original); CollectionAssert.AreEqual(original, copy); } finally { original.CollectionChanged -= handler; } original.Add(42); CollectionAssert.AreNotEqual(original, copy); }
public static void InvokeCollectionChanged(NotifyCollectionChangedEventHandler collectionChanged, object sender, NotifyCollectionChangedEventArgs e) { foreach (NotifyCollectionChangedEventHandler nh in collectionChanged.GetInvocationList()) { var dispObj = nh.Target as DispatcherObject; if (dispObj != null) { Dispatcher dispatcher = dispObj.Dispatcher; if (dispatcher != null && !dispatcher.CheckAccess()) { NotifyCollectionChangedEventHandler nh1 = nh; dispatcher.BeginInvoke((Action) (() => nh1.Invoke(sender, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))), DispatcherPriority.DataBind); continue; } } nh.Invoke(sender, IsRangeAction(e) ? new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset) : e); } }
/// <summary> /// Initializes a new instance of the <see cref="ItemsSourceAdapter" /> class. /// </summary> public ItemsSourceAdapter([NotNull] object container, Context context, bool listenCollectionChanges, string dropDownItemTemplateSelectorName = null, string itemTemplateSelectorName = AttachedMemberConstants.ItemTemplateSelector, string dropDownItemTemplateIdName = null, string itemTemplateIdName = AttachedMemberConstants.ItemTemplate) { Should.NotBeNull(container, "container"); _container = container; _itemTemplateProvider = new DataTemplateProvider(container, itemTemplateIdName, itemTemplateSelectorName); _dropDownTemplateProvider = new DataTemplateProvider(container, dropDownItemTemplateIdName ?? AttachedMembers.AdapterView.DropDownItemTemplate, dropDownItemTemplateSelectorName ?? AttachedMembers.AdapterView.DropDownItemTemplateSelector); _layoutInflater = context.GetBindableLayoutInflater(); if (listenCollectionChanges) _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3)); var activityView = context.GetActivity() as IActivityView; if (activityView != null) { _listener = ReflectionExtensions.CreateWeakEventHandler<ItemsSourceAdapter, EventArgs>(this, (adapter, o, arg3) => adapter.ActivityViewOnDestroyed((Activity)o)); activityView.Mediator.Destroyed += _listener.Handle; } }
protected override void StartListening(object source) { //Check if we can subscribe to the source INotifyCollectionChanged INotify = source as INotifyCollectionChanged; System.Diagnostics.Debug.Assert(INotify != null, "Attempt to create weak subscription to object that does not support it"); if (INotify == null) return; NotifyCollectionChangedEventHandler eventHandler = new NotifyCollectionChangedEventHandler(this.OnEvent); eventHandler = ObjectToHandler.GetOrAdd(source, eventHandler); INotify.CollectionChanged += eventHandler; if (CleanupCountdown == 0) { this.ScheduleCleanup(); CleanupCountdown = 5000; } CleanupCountdown--; }
public PropertyNotifier(INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, IList changedItems) { this.collectionChangedObject = obj; this.collectionChangedHandler = collectionChangedHandler; this.collectionChangedEventArgs = new NotifyCollectionChangedEventArgs(action, changedItems); }
public void CollectionChanged_WhenUnsubscribed_ShouldStopReceivingNotifications() { _realm.Write(() => { _realm.Add(new OrderedObject { Order = 0, IsPartOfResults = true }); }); Exception error = null; _realm.Error += (sender, e) => { error = e.GetException(); }; var query = _realm.All <OrderedObject>().Where(o => o.IsPartOfResults).OrderBy(o => o.Order).AsRealmCollection(); var handle = GCHandle.Alloc(query); // prevent this from being collected across event loops try { // wait for the initial notification to come through TestHelpers.RunEventLoop(); var eventArgs = new List <NotifyCollectionChangedEventArgs>(); var handler = new NotifyCollectionChangedEventHandler((sender, e) => { eventArgs.Add(e); }); query.CollectionChanged += handler; Assert.That(error, Is.Null); _realm.Write(() => { _realm.Add(new OrderedObject { Order = 1, IsPartOfResults = true }); }); TestHelpers.RunEventLoop(); Assert.That(error, Is.Null); Assert.That(eventArgs.Count, Is.EqualTo(1)); Assert.That(eventArgs[0].Action, Is.EqualTo(NotifyCollectionChangedAction.Add)); _realm.Write(() => { _realm.Add(new OrderedObject { Order = 2, IsPartOfResults = true }); }); TestHelpers.RunEventLoop(); Assert.That(error, Is.Null); Assert.That(eventArgs.Count, Is.EqualTo(2)); Assert.That(eventArgs.All(e => e.Action == NotifyCollectionChangedAction.Add)); query.CollectionChanged -= handler; _realm.Write(() => { _realm.Add(new OrderedObject { Order = 3, IsPartOfResults = true }); }); TestHelpers.RunEventLoop(); Assert.That(error, Is.Null); Assert.That(eventArgs.Count, Is.EqualTo(2)); Assert.That(eventArgs.All(e => e.Action == NotifyCollectionChangedAction.Add)); } finally { handle.Free(); } }
public static PropertyNotifier Notify(this INotifyCollectionChanged obj, PropertyChangingEventHandler propertyChangingHandler, PropertyChangedEventHandler propertyChangedHandler, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, object newItem, object oldItem, int index, params string[] properties) { return(new PropertyNotifier(obj, propertyChangingHandler, propertyChangedHandler, collectionChangedHandler, action, newItem, oldItem, index, properties)); }
/// <summary> /// Clears all <see cref="CollectionChanged"/> event handlers /// </summary> public void ClearCollectionChangedEvents() => _changed = null;
public WeakHandler(object source, NotifyCollectionChangedEventHandler originalHandler) { this.source = new WeakReference(source); this.originalHandler = new WeakReference(originalHandler); }
private static IObservable <CollectionChangedData <TItem> > ItemsPropertyChange <TCollection, TItem>( TCollection collection, Predicate <string> isPropertyNameRelevant) where TCollection : IList <TItem>, INotifyCollectionChanged { return(Observable.Create <CollectionChangedData <TItem> >( o => { var trackedItems = new List <INotifyPropertyChanged>(); PropertyChangedEventHandler onItemChanged = (sender, e) => { if (isPropertyNameRelevant(e.PropertyName)) { var payload = new CollectionChangedData <TItem>((TItem)sender); o.OnNext(payload); } }; Action <IEnumerable <TItem> > registerItemChangeHandlers = items => { foreach (var notifier in items.OfType <INotifyPropertyChanged>()) { trackedItems.Add(notifier); notifier.PropertyChanged += onItemChanged; } }; Action <IEnumerable <TItem> > unRegisterItemChangeHandlers = items => { foreach (var notifier in items.OfType <INotifyPropertyChanged>()) { notifier.PropertyChanged -= onItemChanged; trackedItems.Remove(notifier); } }; NotifyCollectionChangedEventHandler onCollectionChanged = (sender, e) => { if (e.Action == NotifyCollectionChangedAction.Reset) { foreach (var notifier in trackedItems) { notifier.PropertyChanged -= onItemChanged; } var payload = new CollectionChangedData <TItem>(trackedItems, collection); trackedItems.Clear(); registerItemChangeHandlers(collection); o.OnNext(payload); } else { var payload = new CollectionChangedData <TItem>(e); unRegisterItemChangeHandlers(payload.OldItems); registerItemChangeHandlers(payload.NewItems); o.OnNext(payload); } }; registerItemChangeHandlers(collection); collection.CollectionChanged += onCollectionChanged; return Disposable.Create( () => { collection.CollectionChanged -= onCollectionChanged; unRegisterItemChangeHandlers(collection); }); })); }
public PropertyNotifier(INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, object newItem, object oldItem, int index) { this.collectionChangedObject = obj; this.collectionChangedHandler = collectionChangedHandler; this.collectionChangedEventArgs = new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index); }
public static PropertyNotifier Notify(this INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, object newItem, object oldItem, int index) { return(new PropertyNotifier(obj, collectionChangedHandler, action, newItem, oldItem, index)); }
public static PropertyNotifier Notify(this INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, IList newItems, IList oldItems) { return(new PropertyNotifier(obj, collectionChangedHandler, action, newItems, oldItems)); }
private void initializeFromSource() { if (_sourceNotifyCollectionChangedEventHandler != null) { int itemInfosCount = _itemInfos.Count; for (int index = 0; index < itemInfosCount; index++) { ItemInfo itemInfo = _itemInfos[index]; ExpressionWatcher expressionWatcher = itemInfo.ExpressionWatcher; expressionWatcher.Dispose(); } int capacity = _sourceScalar != null?Utils.getCapacity(_sourceScalar) : Utils.getCapacity(_source); _itemInfos = new List <ItemInfo>(capacity); _sourcePositions = new Positions <ItemInfo>(_itemInfos); if (_rootSourceWrapper) { _sourceAsList.CollectionChanged -= _sourceNotifyCollectionChangedEventHandler; } else { _sourceAsList.CollectionChanged -= _sourceWeakNotifyCollectionChangedEventHandler.Handle; _sourceWeakNotifyCollectionChangedEventHandler = null; } _sourceNotifyCollectionChangedEventHandler = null; } _predicatePassedCount = 0; if (_sourceScalar != null) { _source = _sourceScalar.Value; } _sourceAsList = null; if (_source != null) { if (_source is ObservableCollectionWithChangeMarker <TSourceItem> sourceAsList) { _sourceAsList = sourceAsList; _rootSourceWrapper = false; } else { _sourceAsList = new RootSourceWrapper <TSourceItem>(_source); _rootSourceWrapper = true; } _lastProcessedSourceChangeMarker = _sourceAsList.ChangeMarkerField; int count = _sourceAsList.Count; for (int sourceIndex = 0; sourceIndex < count; sourceIndex++) { TSourceItem sourceItem = _sourceAsList[sourceIndex]; ItemInfo itemInfo = registerSourceItem(sourceItem, sourceIndex); if (ApplyPredicate(sourceIndex)) { _predicatePassedCount++; itemInfo.PredicateResult = true; } } _sourceNotifyCollectionChangedEventHandler = handleSourceCollectionChanged; if (_rootSourceWrapper) { _sourceAsList.CollectionChanged += _sourceNotifyCollectionChangedEventHandler; } else { _sourceWeakNotifyCollectionChangedEventHandler = new WeakNotifyCollectionChangedEventHandler(_sourceNotifyCollectionChangedEventHandler); _sourceAsList.CollectionChanged += _sourceWeakNotifyCollectionChangedEventHandler.Handle; } calculateValue(); } else { if (_value) { setValue(false); } } }
/// <summary> /// Invokes an action for each item in a collection and subsequently each item added or /// removed from the collection. /// </summary> /// <typeparam name="T">The type of the collection items.</typeparam> /// <param name="collection">The collection.</param> /// <param name="added"> /// An action called initially for each item in the collection and subsequently for each /// item added to the collection. The parameters passed are the index in the collection and /// the item. /// </param> /// <param name="removed"> /// An action called for each item removed from the collection. The parameters passed are /// the index in the collection and the item. /// </param> /// <param name="reset"> /// An action called when the collection is reset. This will be followed by calls to /// <paramref name="added"/> for each item present in the collection after the reset. /// </param> /// <param name="weakSubscription"> /// Indicates if a weak subscription should be used to track changes to the collection. /// </param> /// <returns>A disposable used to terminate the subscription.</returns> public static IDisposable ForEachItem <T>( this IAvaloniaReadOnlyList <T> collection, Action <int, T> added, Action <int, T> removed, Action reset, bool weakSubscription = false) { void Add(int index, IList items) { foreach (T item in items) { added(index++, item); } } void Remove(int index, IList items) { for (var i = items.Count - 1; i >= 0; --i) { removed(index + i, (T)items[i]); } } NotifyCollectionChangedEventHandler handler = (_, e) => { switch (e.Action) { case NotifyCollectionChangedAction.Add: Add(e.NewStartingIndex, e.NewItems); break; case NotifyCollectionChangedAction.Move: case NotifyCollectionChangedAction.Replace: Remove(e.OldStartingIndex, e.OldItems); Add(e.NewStartingIndex, e.NewItems); break; case NotifyCollectionChangedAction.Remove: Remove(e.OldStartingIndex, e.OldItems); break; case NotifyCollectionChangedAction.Reset: if (reset == null) { throw new InvalidOperationException( "Reset called on collection without reset handler."); } reset(); Add(0, (IList)collection); break; } }; Add(0, (IList)collection); if (weakSubscription) { return(collection.WeakSubscribe(handler)); } else { collection.CollectionChanged += handler; return(Disposable.Create(() => collection.CollectionChanged -= handler)); } }
public ObservableList() : base() { CollectionChanged += new NotifyCollectionChangedEventHandler(nObservableCollection_CollectionChanged); }
void RunView(UIViewType viewType, ViewWithData arg = null) { if (requestedTarget?.ViewType == viewType || (requestedTarget?.ViewType == UIViewType.None && requestedTarget?.MainFlow == CurrentFlow)) { arg = requestedTarget; } if (arg == null) { arg = new ViewWithData { ActiveFlow = activeFlow, MainFlow = selectedFlow, ViewType = viewType } } ; bool firstTime = CreateViewAndViewModel(viewType, arg); var view = GetObjectsForFlow(activeFlow)[viewType].View; transition.OnNext(new LoadData { Flow = activeFlow, View = view, Data = arg }); // controller might have been stopped in the OnNext above if (IsStopped) { return; } // if it's not the first time we've shown this view, no need // to set it up if (!firstTime) { return; } SetupView(viewType, view.ViewModel); } void SetupView(UIViewType viewType, IViewModel viewModel) { var list = GetObjectsForFlow(activeFlow); var pair = list[viewType]; var hasDone = viewModel as IHasDone; var hasCancel = viewModel as IHasCancel; // 2FA is set up when login is set up, so nothing to do if (viewType == UIViewType.TwoFactor) { return; } // we're setting up the login dialog, we need to setup the 2fa as // well to continue the flow if it's needed, since the // authenticationresult callback won't happen until // everything is done if (viewType == UIViewType.Login) { var pair2fa = list[UIViewType.TwoFactor]; pair2fa.AddHandler(((IDialogViewModel)pair2fa.ViewModel).WhenAny(x => x.IsShowing, x => x.Value) .Where(x => x) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => Fire(Trigger.Next))); pair2fa.AddHandler(((IHasCancel)pair2fa.ViewModel).Cancel .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Cancel) ? Trigger.Cancel : Trigger.Finish))); if (hasDone != null) { pair.AddHandler(hasDone.Done .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => Fire(Trigger.Finish))); } } else if (hasDone != null) { pair.AddHandler(hasDone.Done .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Next) ? Trigger.Next : Trigger.Finish))); } if (hasCancel != null) { pair.AddHandler(hasCancel.Cancel .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Cancel) ? Trigger.Cancel : Trigger.Finish))); } } /// <summary> /// Creates View/ViewModel instances for the specified <paramref name="viewType"/> if they /// haven't been created yet in the current flow /// </summary> /// <param name="viewType"></param> /// <returns>true if the View/ViewModel didn't exist and had to be created</returns> bool CreateViewAndViewModel(UIViewType viewType, ViewWithData data = null) { var list = GetObjectsForFlow(activeFlow); if (viewType == UIViewType.Login) { if (!list.ContainsKey(viewType)) { var d = factory.CreateViewAndViewModel(UIViewType.TwoFactor); list.Add(UIViewType.TwoFactor, d); } } // 2fa view/viewmodel is created when login is created 'cause login needs the 2fa viewmodel // so the only thing we want to do is connect the viewmodel to the view when it's showing else if (viewType == UIViewType.TwoFactor) { var d = list[viewType]; if (d.View.ViewModel == null) { d.ViewModel.Initialize(data); d.View.DataContext = d.ViewModel; } } IUIPair pair = null; var firstTime = !list.TryGetValue(viewType, out pair); if (firstTime) { pair = factory.CreateViewAndViewModel(viewType); } pair.ViewModel.Initialize(data); if (firstTime) { pair.View.DataContext = pair.ViewModel; list.Add(viewType, pair); } return(firstTime); } /// <summary> /// Returns the view/viewmodel pair for a given flow /// </summary> Dictionary <UIViewType, IUIPair> GetObjectsForFlow(UIControllerFlow flow) { Dictionary <UIViewType, IUIPair> list; if (!uiObjects.TryGetValue(flow, out list)) { list = new Dictionary <UIViewType, IUIPair>(); uiObjects.Add(flow, list); } return(list); } void Fire(Trigger next, ViewWithData arg = null) { Debug.WriteLine("Firing {0} from {1} ({2})", next, uiStateMachine.State, GetHashCode()); if (triggers.ContainsKey(next)) { uiStateMachine.Fire(triggers[next], arg); } else { uiStateMachine.Fire(next); } } UIViewType Go(Trigger trigger) { return(Go(trigger, activeFlow)); } UIViewType Go(Trigger trigger, UIControllerFlow flow) { var m = machines[flow]; Debug.WriteLine("Firing {0} from {1} for flow {2} ({3})", trigger, m.State, flow, GetHashCode()); m.Fire(trigger); return(m.State); } void Reset() { if (connectionAdded != null) { connectionManager.Connections.CollectionChanged -= connectionAdded; } connectionAdded = null; var tr = transition; var cmp = completion; transition = null; completion = null; disposables.Clear(); tr?.Dispose(); cmp?.Dispose(); stopping = false; connection = null; } bool disposed; // To detect redundant calls
public void Start() { if (connection != null) { if (selectedFlow != UIControllerFlow.Authentication) { gitHubServiceProvider.AddService(this, connection); } else // sanity check: it makes zero sense to pass a connection in when calling the auth flow { Debug.Assert(false, "Calling the auth flow with a connection makes no sense!"); } connection.Login() .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => { }, () => { Debug.WriteLine("Start ({0})", GetHashCode()); Fire(Trigger.Next); }); } else { connectionManager .GetLoggedInConnections(hosts) .FirstOrDefaultAsync() .Select(c => { bool loggedin = c != null; if (selectedFlow != UIControllerFlow.Authentication) { if (loggedin) // register the first available connection so the viewmodel can use it { connection = c; gitHubServiceProvider.AddService(this, c); } else { // a connection will be added to the list when auth is done, register it so the next // viewmodel can use it connectionAdded = (s, e) => { if (e.Action == NotifyCollectionChangedAction.Add) { connection = e.NewItems[0] as IConnection; if (connection != null) { gitHubServiceProvider.AddService(typeof(IConnection), this, connection); } } }; connectionManager.Connections.CollectionChanged += connectionAdded; } } return(loggedin); }) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => { }, () => { Debug.WriteLine("Start ({0})", GetHashCode()); Fire(Trigger.Next); }); } }
public static IObservable <NotifyCollectionChangedEventArgs> WhenCollectionChanged(this INotifyCollectionChanged collection) => Observable.Create <NotifyCollectionChangedEventArgs>(ob => { var handler = new NotifyCollectionChangedEventHandler((sender, args) => ob.OnNext(args)); collection.CollectionChanged += handler; return(() => collection.CollectionChanged -= handler); });
public PropertyNotifier(INotifyCollectionChanged obj, PropertyChangingEventHandler propertyChangingHandler, PropertyChangedEventHandler propertyChangedHandler, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, object newItem, object oldItem, int index, params string[] properties) { this.collectionChangedObject = obj; this.collectionChangedHandler = collectionChangedHandler; this.collectionChangedEventArgs = new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index); }
public DeeplyObservableCollection() : base() { CollectionChanged += new NotifyCollectionChangedEventHandler(DeeplyObservableCollection_CollectionChanged); }
/// <summary> /// Constructors /// </summary> public ObservableCollectionEx() : base() { CollectionChanged += new NotifyCollectionChangedEventHandler(ObservableCollectionEx_CollectionChanged); }
public static PropertyNotifier Notify(this INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, IList changedItems, int index, int oldIndex) { return(new PropertyNotifier(obj, collectionChangedHandler, action, changedItems, index, oldIndex)); }
public ItemsSourceTableViewSource([NotNull] UITableView tableView, string itemTemplate = AttachedMemberConstants.ItemTemplate) : base(tableView, itemTemplate) { _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3)); }
public static PropertyNotifier Notify(this INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, object changedItem) { return(new PropertyNotifier(obj, collectionChangedHandler, action, changedItem)); }
private void initializeFromSources() { if (_outerSourceNotifyCollectionChangedEventHandler != null) { _outerSource.CollectionChanged -= _outerSourceWeakNotifyCollectionChangedEventHandler.Handle; _outerSourceNotifyCollectionChangedEventHandler = null; _outerSourceWeakNotifyCollectionChangedEventHandler = null; } if (_innerSourceNotifyCollectionChangedEventHandler != null) { _innerSource.CollectionChanged -= _innerSourceWeakNotifyCollectionChangedEventHandler.Handle; _innerSourceNotifyCollectionChangedEventHandler = null; _innerSourceWeakNotifyCollectionChangedEventHandler = null; } if (_innerSourceAsINotifyPropertyChanged != null) { _innerSourceAsINotifyPropertyChanged.PropertyChanged -= _innerSourceWeakPropertyChangedEventHandler.Handle; _innerSourceAsINotifyPropertyChanged = null; _innerSourcePropertyChangedEventHandler = null; _innerSourceWeakPropertyChangedEventHandler = null; } if (_outerSourceAsINotifyPropertyChanged != null) { _outerSourceAsINotifyPropertyChanged.PropertyChanged -= _outerSourceWeakPropertyChangedEventHandler.Handle; _outerSourceAsINotifyPropertyChanged = null; _outerSourcePropertyChangedEventHandler = null; _outerSourceWeakPropertyChangedEventHandler = null; } if (_outerSource != null || _innerSource != null) { baseClearItems(); } if (_outerSourceScalar != null) { _outerSource = _outerSourceScalar.Value; } _outerSourceAsList = (IList <TOuterSourceItem>)_outerSource; if (_innerSourceScalar != null) { _innerSource = _innerSourceScalar.Value; } _innerSourceAsList = (IList <TInnerSourceItem>)_innerSource; if (_outerSource != null && _innerSource != null) { _outerSourceAsObservableCollectionWithChangeMarker = _outerSourceAsList as ObservableCollectionWithChangeMarker <TOuterSourceItem>; if (_outerSourceAsObservableCollectionWithChangeMarker != null) { _lastProcessedOuterSourceChangeMarker = _outerSourceAsObservableCollectionWithChangeMarker.ChangeMarkerField; } else { _outerSourceAsINotifyPropertyChanged = (INotifyPropertyChanged)_outerSource; _outerSourcePropertyChangedEventHandler = (sender, args) => { if (args.PropertyName == "Item[]") { _outerSourceIndexerPropertyChangedEventRaised = true; // ObservableCollection raises this before CollectionChanged event raising } }; _outerSourceWeakPropertyChangedEventHandler = new WeakPropertyChangedEventHandler(_outerSourcePropertyChangedEventHandler); _outerSourceAsINotifyPropertyChanged.PropertyChanged += _outerSourceWeakPropertyChangedEventHandler.Handle; } _innerSourceAsObservableCollectionWithChangeMarker = _innerSourceAsList as ObservableCollectionWithChangeMarker <TInnerSourceItem>; if (_innerSourceAsObservableCollectionWithChangeMarker != null) { _lastProcessedInnerSourceChangeMarker = _innerSourceAsObservableCollectionWithChangeMarker.ChangeMarkerField; } else { _innerSourceAsINotifyPropertyChanged = (INotifyPropertyChanged)_innerSource; _innerSourcePropertyChangedEventHandler = (sender, args) => { if (args.PropertyName == "Item[]") { _innerSourceIndexerPropertyChangedEventRaised = true; // ObservableCollection raises this before CollectionChanged event raising } }; _innerSourceWeakPropertyChangedEventHandler = new WeakPropertyChangedEventHandler(_innerSourcePropertyChangedEventHandler); _innerSourceAsINotifyPropertyChanged.PropertyChanged += _innerSourceWeakPropertyChangedEventHandler.Handle; } // ReSharper disable once PossibleNullReferenceException int outerSourceCount = _outerSourceAsList.Count; // ReSharper disable once PossibleNullReferenceException int innerSourceCount = _innerSourceAsList.Count; int baseIndex = 0; for (int outerSourceIndex = 0; outerSourceIndex < outerSourceCount; outerSourceIndex++) { TOuterSourceItem sourceOuterItem = _outerSourceAsList[outerSourceIndex]; for (int innerSourceIndex = 0; innerSourceIndex < innerSourceCount; innerSourceIndex++) { TInnerSourceItem sourceInnerItem = _innerSourceAsList[innerSourceIndex]; JoinPair <TOuterSourceItem, TInnerSourceItem> joinPair = new JoinPair <TOuterSourceItem, TInnerSourceItem>( sourceOuterItem, sourceInnerItem); baseInsertItem(baseIndex + innerSourceIndex, joinPair); } baseIndex = baseIndex + innerSourceCount; } _outerSourceNotifyCollectionChangedEventHandler = handleOuterSourceCollectionChanged; _outerSourceWeakNotifyCollectionChangedEventHandler = new WeakNotifyCollectionChangedEventHandler(_outerSourceNotifyCollectionChangedEventHandler); _outerSource.CollectionChanged += _outerSourceWeakNotifyCollectionChangedEventHandler.Handle; _innerSourceNotifyCollectionChangedEventHandler = handleInnerSourceCollectionChanged; _innerSourceWeakNotifyCollectionChangedEventHandler = new WeakNotifyCollectionChangedEventHandler(_innerSourceNotifyCollectionChangedEventHandler); _innerSource.CollectionChanged += _innerSourceWeakNotifyCollectionChangedEventHandler.Handle; } }
public PropertyNotifier(INotifyCollectionChanged obj, PropertyChangingEventHandler propertyChangingHandler, PropertyChangedEventHandler propertyChangedHandler, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, IList changedItems, int startingIndex, params string[] properties) { this.collectionChangedObject = obj; this.collectionChangedHandler = collectionChangedHandler; this.collectionChangedEventArgs = new NotifyCollectionChangedEventArgs(action, changedItems, startingIndex); }
public VisualElementTracker() { _collectionChangedHandler = ModelGestureRecognizersOnCollectionChanged; }
public PropertyNotifier(INotifyCollectionChanged obj, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, IList newItems, IList oldItems, int startingIndex) { this.collectionChangedObject = obj; this.collectionChangedHandler = collectionChangedHandler; this.collectionChangedEventArgs = new NotifyCollectionChangedEventArgs(action, newItems, oldItems, startingIndex); }
public void CustomCollectionTest() { var originalCollection = new CustomCollection <MyModel>(true) { new MyModel(), new MyModel(), new MyModel() }; using var synchronizingCollection = new SynchronizingCollectionCore <MyDataModel, MyModel>( originalCollection, m => new MyDataModel(m)); AssertHelper.SequenceEqual(originalCollection, synchronizingCollection.Select(dm => dm.Model)); // Check add operation with collection changed event. bool handlerCalled = false; NotifyCollectionChangedEventHandler handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action); Assert.AreEqual(3, e.NewStartingIndex); Assert.AreEqual(originalCollection.Last(), e.NewItems.Cast <MyDataModel>().Single().Model); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Add(new MyModel()); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Compare the collections AssertHelper.SequenceEqual(originalCollection, synchronizingCollection.Select(dm => dm.Model)); // Check remove operation with collection changed event. MyModel itemToRemove = originalCollection[2]; handlerCalled = false; handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Remove, e.Action); Assert.AreEqual(2, e.OldStartingIndex); Assert.AreEqual(itemToRemove, e.OldItems.Cast <MyDataModel>().Single().Model); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Remove(itemToRemove); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Check replace operation with collection changed event. MyModel itemToReplace = originalCollection[1]; int handlerCalledCount = 0; handler = (sender, e) => { Assert.AreEqual(synchronizingCollection, sender); if (handlerCalledCount == 0) { Assert.AreEqual(NotifyCollectionChangedAction.Remove, e.Action); Assert.AreEqual(itemToReplace, e.OldItems.Cast <MyDataModel>().Single().Model); } else { Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action); Assert.AreEqual(originalCollection[1], e.NewItems.Cast <MyDataModel>().Single().Model); } handlerCalledCount++; }; synchronizingCollection.CollectionChanged += handler; originalCollection[1] = new MyModel(); synchronizingCollection.CollectionChanged -= handler; Assert.AreEqual(2, handlerCalledCount); // Check reset operation with collection changed event. var newItems = new List <MyModel>() { new MyModel(), new MyModel() }; handlerCalledCount = 0; handler = (sender, e) => { Assert.AreEqual(synchronizingCollection, sender); if (handlerCalledCount == 0) { Assert.AreEqual(NotifyCollectionChangedAction.Reset, e.Action); } else { Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action); } handlerCalledCount++; }; synchronizingCollection.CollectionChanged += handler; originalCollection.Reset(newItems); synchronizingCollection.CollectionChanged -= handler; Assert.AreEqual(3, handlerCalledCount); AssertHelper.SequenceEqual(newItems, synchronizingCollection.Select(dm => dm.Model)); }
public void ObservableCollectionTest() { var originalCollection = new ObservableCollection <MyModel>() { new MyModel(), new MyModel(), new MyModel() }; using var synchronizingCollection = new SynchronizingCollectionCore <MyDataModel, MyModel>(originalCollection, m => new MyDataModel(m)); AssertHelper.SequenceEqual(originalCollection, synchronizingCollection.Select(dm => dm.Model)); // Check add operation with collection changed event. bool handlerCalled = false; NotifyCollectionChangedEventHandler handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action); Assert.AreEqual(3, e.NewStartingIndex); Assert.AreEqual(originalCollection.Last(), e.NewItems.Cast <MyDataModel>().Single().Model); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Add(new MyModel()); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Check insert at index 0 operation with collection changed event. handlerCalled = false; handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action); Assert.AreEqual(0, e.NewStartingIndex); Assert.AreEqual(originalCollection[0], e.NewItems.Cast <MyDataModel>().Single().Model); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Insert(0, new MyModel()); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Compare the collections AssertHelper.SequenceEqual(originalCollection, synchronizingCollection.Select(dm => dm.Model)); // Check remove operation with collection changed event. MyModel itemToRemove = originalCollection[2]; handlerCalled = false; handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Remove, e.Action); Assert.AreEqual(2, e.OldStartingIndex); Assert.AreEqual(itemToRemove, e.OldItems.Cast <MyDataModel>().Single().Model); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Remove(itemToRemove); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Check replace operation with collection changed event. MyModel itemToReplace = originalCollection[1]; handlerCalled = false; handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Replace, e.Action); Assert.AreEqual(1, e.NewStartingIndex); Assert.AreEqual(1, e.OldStartingIndex); Assert.AreEqual(originalCollection[1], e.NewItems.Cast <MyDataModel>().Single().Model); Assert.AreEqual(itemToReplace, e.OldItems.Cast <MyDataModel>().Single().Model); }; synchronizingCollection.CollectionChanged += handler; originalCollection[1] = new MyModel(); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Check move operation with collection changed event. handlerCalled = false; handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Move, e.Action); Assert.AreEqual(0, e.OldStartingIndex); Assert.AreEqual(2, e.NewStartingIndex); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Move(0, 2); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); // Check clear operation with collection changed event. handlerCalled = false; handler = (sender, e) => { handlerCalled = true; Assert.AreEqual(synchronizingCollection, sender); Assert.AreEqual(NotifyCollectionChangedAction.Reset, e.Action); }; synchronizingCollection.CollectionChanged += handler; originalCollection.Clear(); synchronizingCollection.CollectionChanged -= handler; Assert.IsTrue(handlerCalled); Assert.IsFalse(synchronizingCollection.Any()); }
public static PropertyNotifier Notify(this INotifyCollectionChanged obj, PropertyChangingEventHandler propertyChangingHandler, PropertyChangedEventHandler propertyChangedHandler, NotifyCollectionChangedEventHandler collectionChangedHandler, NotifyCollectionChangedAction action, IList changedItems, int index, int oldIndex, params string[] properties) { return(new PropertyNotifier(obj, propertyChangingHandler, propertyChangedHandler, collectionChangedHandler, action, changedItems.Cast <object>().ToList(), index, oldIndex, properties)); }
protected ItemsSourceGeneratorBase() { _handler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this, (@base, o, arg3) => @base.OnCollectionChanged(arg3)); }
public ObservableCollectionEx(IEnumerable <T> l) : base(l) { CollectionChanged += new NotifyCollectionChangedEventHandler(ObservableCollectionEx_CollectionChanged); }