Beispiel #1
0
 protected override void AssertObject(FilterableNotifiableCollection <string> deserializedObj)
 {
     deserializedObj.Items.ShouldBeType <ObservableCollection <string> >();
     deserializedObj.SequenceEqual(TestExtensions.TestStrings).ShouldBeTrue();
     deserializedObj.IsNotificationsSuspended.ShouldBeFalse();
     deserializedObj.EventsTracker.ShouldNotBeNull();
 }
        public BuildingListViewModel()
        {
            initGetNewBuildings();

            GetBuildingsInQuery        = new FilterableNotifiableCollection <BuildingInCity>(AppCache.ApplicationViewModel.UserProfile.City.BuildingsInCity);
            GetBuildingsInQuery.Filter = new Predicate <BuildingInCity>(GetBuildingsInQueryFilter);

            GetBuildingsCompleted        = new FilterableNotifiableCollection <BuildingInCity>(AppCache.ApplicationViewModel.UserProfile.City.BuildingsInCity);
            GetBuildingsCompleted.Filter = new Predicate <BuildingInCity>(GetBuildingsCompletedFilter);
        }
        public BuildingListViewModel()
        {
            initGetNewBuildings();

            GetBuildingsInQuery = new FilterableNotifiableCollection<BuildingInCity>(AppCache.ApplicationViewModel.UserProfile.City.BuildingsInCity);
            GetBuildingsInQuery.Filter = new Predicate<BuildingInCity>(GetBuildingsInQueryFilter);

            GetBuildingsCompleted = new FilterableNotifiableCollection<BuildingInCity>(AppCache.ApplicationViewModel.UserProfile.City.BuildingsInCity);
            GetBuildingsCompleted.Filter = new Predicate<BuildingInCity>(GetBuildingsCompletedFilter);
        }
        public BuildingListViewModel()
        {
            GetNewBuildings        = new FilterableNotifiableCollection <Building>(AppCache.ApplicationViewModel.Buildings);
            GetNewBuildings.Filter = new Predicate <Building>(GetNewBuildingsFilter);

            GetBuildingsInQuery =
                new FilterableNotifiableCollection <Building>(
                    AppCache.ApplicationViewModel.UserProfile.City.BuildingsInCity.Where(
                        b => b.Status == BuildingStatuses.InQuery).Select(s => s.Building).ToObservableCollection());
            GetBuildingsInQuery.Filter = new Predicate <Building>(GetBuildingsInQueryFilter);
        }
        public BuildingListViewModel()
        {
            GetNewBuildings = new FilterableNotifiableCollection<Building>(AppCache.ApplicationViewModel.Buildings);
            GetNewBuildings.Filter = new Predicate<Building>(GetNewBuildingsFilter);

            GetBuildingsInQuery =
                new FilterableNotifiableCollection<Building>(
                    AppCache.ApplicationViewModel.UserProfile.City.BuildingsInCity.Where(
                        b => b.Status == BuildingStatuses.InQuery).Select(s => s.Building).ToObservableCollection());
                GetBuildingsInQuery.Filter = new Predicate<Building>(GetBuildingsInQueryFilter);
        }
Beispiel #6
0
        public override void GlobalSettingTest()
        {
            ApplicationSettings.SetDefaultValues();
            //By default
            var collection = new FilterableNotifiableCollection <Item>();

            collection.ExecutionMode.ShouldEqual(ExecutionMode.AsynchronousOnUiThread);

            ApplicationSettings.SynchronizedCollectionExecutionMode = ExecutionMode.None;
            collection = new FilterableNotifiableCollection <Item>();
            collection.ExecutionMode.ShouldEqual(ExecutionMode.None);
        }
Beispiel #7
0
        public void CollectionShouldTrackChangesCorrectInSourceCollection()
        {
            const int count                = 10;
            var       collection           = new ObservableCollection <Item>();
            var       filterableCollection = new FilterableNotifiableCollection <Item>(collection, ThreadManagerMock)
            {
                Filter = _ => true
            };
            var collectionTracker = new NotifiableCollectionTracker <Item>(filterableCollection);

            var item   = new Item();
            var items  = new[] { new Item(), new Item(), new Item() };
            var items2 = new[] { new Item {
                                     Hidden = true
                                 }, new Item(), new Item {
                                     Hidden = true
                                 } };

            for (int i = 0; i < count; i++)
            {
                collection.AddRange(items);
                collection.SequenceEqual(filterableCollection).ShouldBeTrue();
                collection.AddRange(items2);
                collection.SequenceEqual(filterableCollection).ShouldBeTrue();
                collection.RemoveRange(items);
                collection.SequenceEqual(filterableCollection).ShouldBeTrue();
            }
            for (int i = 0; i < collection.Count; i++)
            {
                collection[i] = item;
                collection.SequenceEqual(filterableCollection).ShouldBeTrue();
            }

            ThreadManagerMock.InvokeOnUiThreadAsync();
            collectionTracker.AssertChangedEquals();
            collection.Count.ShouldEqual(count * items2.Length);

            collection.Clear();
            ThreadManagerMock.InvokeOnUiThreadAsync();
            collection.SequenceEqual(filterableCollection).ShouldBeTrue();
            collection.Count.ShouldEqual(0);
            collectionTracker.AssertChangedEquals();
        }
Beispiel #8
0
        public void SetOriginalItemsSource <TItemsSource>(TItemsSource originalItemsSource)
            where TItemsSource : IList <T>, INotifyCollectionChanged, IList
        {
            EnsureNotDisposed();
            Should.NotBeNull(originalItemsSource, "originalItemsSource");
            lock (_weakPropertyHandler)
            {
                INotifyCollectionChanging collectionChanging;
                if (_originalData != null)
                {
                    collectionChanging = _originalData as INotifyCollectionChanging;
                    if (collectionChanging != null)
                    {
                        collectionChanging.CollectionChanging -= RaiseCollectionChanging;
                    }
                    ((INotifyCollectionChanged)(_originalData)).CollectionChanged -= RaiseCollectionChanged;
                    if (_originalData.Count != 0)
                    {
                        originalItemsSource.AddRange(_originalData);
                    }
                }
                _filterableItemsSource = new FilterableNotifiableCollection <T>(originalItemsSource);
                collectionChanging     = originalItemsSource as INotifyCollectionChanging;
                if (collectionChanging != null)
                {
                    collectionChanging.CollectionChanging += RaiseCollectionChanging;
                }
                originalItemsSource.CollectionChanged += RaiseCollectionChanged;

                _originalData = originalItemsSource;
                var list = ServiceProvider.TryDecorate(FilterableItemsSource);
                Should.BeOfType <INotifiableCollection <T> >(list, "DecoratedItemsSource");
                Should.BeOfType <INotifiableCollection>(list, "DecoratedItemsSource");
                _itemsSource = (INotifiableCollection <T>)list;
            }
            UpdateFilter();
            OnPropertyChanged("ItemsSource");
            OnPropertyChanged("OriginalItemsSource");
        }
Beispiel #9
0
        public void SetOriginalItemsSource <TItemsSource>(TItemsSource originalItemsSource)
            where TItemsSource : IList <T>, INotifyCollectionChanged, IList
        {
            EnsureNotDisposed();
            Should.NotBeNull(originalItemsSource, nameof(originalItemsSource));
            INotifyCollectionChanging collectionChanging;

            if (_originalData != null)
            {
                collectionChanging = _originalData as INotifyCollectionChanging;
                if (collectionChanging != null)
                {
                    collectionChanging.CollectionChanging -= RaiseCollectionChanging;
                }
                ((INotifyCollectionChanged)_originalData).CollectionChanged -= RaiseCollectionChanged;
                if (_originalData.Count != 0)
                {
                    originalItemsSource.AddRange(_originalData, true);
                }
            }
            _filterableItemsSource = new FilterableNotifiableCollection <T>(originalItemsSource);
            collectionChanging     = originalItemsSource as INotifyCollectionChanging;
            if (collectionChanging != null)
            {
                collectionChanging.CollectionChanging += RaiseCollectionChanging;
            }
            originalItemsSource.CollectionChanged += RaiseCollectionChanged;

            _originalData = originalItemsSource;
            var list = ToolkitServiceProvider.TryDecorate(this, FilterableItemsSource);

            Should.BeOfType <INotifiableCollection <T> >(list, "DecoratedItemsSource");
            _itemsSource = (INotifiableCollection <T>)list;
            UpdateFilter();
            OnPropertyChanged(nameof(ItemsSource));
            OnPropertyChanged(nameof(OriginalItemsSource));
            RaiseItemsSourceChanged(_itemsSource);
        }
 public void initGetNewBuildings()
 {
     GetNewBuildings        = new FilterableNotifiableCollection <Building>(AppCache.ApplicationViewModel.AllBuildings);
     GetNewBuildings.Filter = new Predicate <Building>(GetNewBuildingsFilter);
 }
 public void initGetNewBuildings()
 {
     GetNewBuildings = new FilterableNotifiableCollection<Building>(AppCache.ApplicationViewModel.AllBuildings);
     GetNewBuildings.Filter = new Predicate<Building>(GetNewBuildingsFilter);
 }