public void ResetWithListBoxTest()
        {
            ObservableCollection <int> oc = new ObservableCollection <int>()
            {
                1, 2, 4, 5
            };
            PagedCollectionView cv = new PagedCollectionView(oc);

            ListBox lb = new ListBox();

            lb.ItemsSource = cv;

            this.CreateAsyncTask(
                lb,
                delegate
            {
                Assert.AreEqual(4, lb.Items.Count);
                cv.Refresh();

                Assert.AreEqual(4, lb.Items.Count);
                oc.Insert(2, 3);

                Assert.AreEqual(5, lb.Items.Count);
                cv.Refresh();

                Assert.AreEqual(5, lb.Items.Count);
            });

            EnqueueTestComplete();
        }
        public void CannotRefreshTest()
        {
            ObservableCollection <TestClass> collection = new ObservableCollection <TestClass>()
            {
                new TestClass()
            };
            PagedCollectionView pcv = new PagedCollectionView(collection);

            // show that we will throw an exception if we try to change the PageSize while adding
            pcv.AddNew();
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedDuringAddOrEdit, "Refresh")),
                delegate
            {
                pcv.Refresh();
            });
            pcv.CancelNew();

            // show that we will throw an exception if we try to change the PageSize while editing
            pcv.EditItem(pcv[0]);
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedDuringAddOrEdit, "Refresh")),
                delegate
            {
                pcv.Refresh();
            });
        }
        public void RefreshWithNonIListSourceTest()
        {
            TestEnumerableCollection list = new TestEnumerableCollection();

            list.Add(new TestClass {
                IntProperty = 1, StringProperty = "Test 1"
            });
            list.Add(new TestClass {
                IntProperty = 2, StringProperty = "Test 2"
            });

            PagedCollectionView pcv = new PagedCollectionView(list);

            pcv.SortDescriptions.Add(new SortDescription("IntProperty", ListSortDirection.Ascending));
            Assert.AreEqual(2, pcv.Count);

            // add items to list and Refresh
            list.Add(new TestClass()
            {
                IntProperty = 3, StringProperty = "Test 3"
            });
            list.Add(new TestClass()
            {
                IntProperty = 4, StringProperty = "Test 4"
            });
            pcv.Refresh();
            Assert.AreEqual(4, pcv.Count);

            // remove items from list and Refresh
            list.RemoveAt(0);
            list.RemoveAt(0);
            pcv.Refresh();
            Assert.AreEqual(2, pcv.Count);
        }
        private void loadOperation_Completed(LoadOperation <DocumentManager.Web.Model.taxpayer> sender)
        {
            TaxPayerList.Clear();
            taxPayerSource.Source = sender.Entities;
            foreach (DocumentManager.Web.Model.taxpayer taxpayer in sender.Entities)
            {
                TaxPayerEntity taxPayerEntity = new TaxPayerEntity();
                taxPayerEntity.TaxPayer = taxpayer;
                taxPayerEntity.Update();

                if (taxPayerEntity.TaxPayerTypeId.HasValue)
                {
                    TaxPayerTypeEntity taxPayerTypeEntity;
                    if (TaxPayerTypeEntityDictionary.TryGetValue(taxPayerEntity.TaxPayerTypeId.Value, out taxPayerTypeEntity))
                    {
                        taxPayerEntity.TaxPayerTypeEntity = taxPayerTypeEntity;
                    }
                }


                TaxPayerList.Add(taxPayerEntity);
            }

            PagedCollectionView lPagedCollectionView = new PagedCollectionView(TaxPayerList);

            lPagedCollectionView.GroupDescriptions.Add(new PropertyGroupDescription("TaxPayerName"));
            TaxpayerView = lPagedCollectionView;
            TaxpayerView.Refresh();
            UpdateChanged("TaxpayerView");
            UpdateChanged("TaxPayerList");
            IsBusy = false;

            finishLoadedTaxpayer();
        }
Beispiel #5
0
        private void FirstGroupComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            string firstGrouping = FirstGroupComboBox.SelectedValue as string;

            firstGrouping = firstGrouping.Replace(" ", string.Empty);
            if (!string.IsNullOrEmpty(firstGrouping))
            {
                data.GroupDescriptions.Add(new PropertyGroupDescription(firstGrouping));
            }

            data.Refresh();
            MainGrid.ItemsSource = data;
        }
Beispiel #6
0
        private void comboBox1_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ComboBoxItem item = comboBox1.SelectedItem as ComboBoxItem;

            if (!item.Content.ToString().Equals("None"))
            {
                data.GroupDescriptions.Clear();
                data.GroupDescriptions.Add(new PropertyGroupDescription(item.Content.ToString()));

                data.Refresh();
                MainGrid.ItemsSource = data;
            }
            else
            {
                data.GroupDescriptions.Clear();
            }
        }
        public void OnCollectionChangedTest()
        {
            List <EditableTestClass>         efbList      = new List <EditableTestClass>();
            ObservableCollection <TestClass> fbCollection = new ObservableCollection <TestClass>();

            PagedCollectionView pcv1 = new PagedCollectionView(efbList);
            PagedCollectionView pcv2 = new PagedCollectionView(fbCollection);

            pcv1.CollectionChanged += new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
            pcv2.CollectionChanged += new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);

            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { pcv1.Refresh(); });

            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { fbCollection.Clear(); });

            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { fbCollection.Add(new TestClass()); });

            EditableTestClass efb;

            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { efb = pcv1.AddNew() as EditableTestClass; });

            pcv1.CommitNew();

            // Add, then Cancel to fire a Remove
            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { pcv1.AddNew(); });

            this._expectedAction = NotifyCollectionChangedAction.Remove;
            this.AssertExpectedEvent(delegate { pcv1.CancelNew(); });

            // Set PageSize to 1 to Reset
            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { pcv1.PageSize = 1; });

            // Remove an Item
            this._expectedAction = NotifyCollectionChangedAction.Remove;
            this.AssertExpectedEvent(delegate { pcv1.RemoveAt(0); });

            pcv2.CollectionChanged -= new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
            pcv1.CollectionChanged -= new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
        }
Beispiel #8
0
        public void SortingWithLocalizationTest()
        {
            ObservableCollection <object> list = new ObservableCollection <object>()
            {
                "al:tinda", "ch:aque", "Cz:ech", "co:te", "hi:zli", "i:erigiyle"
            };

            PagedCollectionView view = new PagedCollectionView(list);

            // first test with the default InvariantCulture to see that it sorts in the correct order
            view.Culture = CultureInfo.InvariantCulture;
            view.SortDescriptions.Add(new SortDescription("", ListSortDirection.Descending));

            Assert.AreEqual(view[0], "i:erigiyle");
            Assert.AreEqual(view[1], "hi:zli");
            Assert.AreEqual(view[2], "Cz:ech");
            Assert.AreEqual(view[3], "co:te");
            Assert.AreEqual(view[4], "ch:aque");
            Assert.AreEqual(view[5], "al:tinda");

            // now test with a Slovik culture applied to make sure that it sorts in the correct order
            view.Culture = new CultureInfo("sk-SK");
            view.Refresh();

            Assert.AreEqual(view[0], "i:erigiyle");
            Assert.AreEqual(view[1], "ch:aque");
            Assert.AreEqual(view[2], "hi:zli");
            Assert.AreEqual(view[3], "Cz:ech");
            Assert.AreEqual(view[4], "co:te");
            Assert.AreEqual(view[5], "al:tinda");

            // now remove the second item and re-insert to verify that sorting with the CultureInfo
            // allows it to be placed back in the same index
            view.RemoveAt(1);
            string str = "ch:aque";

            list.Add(str);
            Assert.AreEqual(str, view[1]);
        }
Beispiel #9
0
 private void ExecuteDetailLevelChanged()
 {
     _pagedCollectionView.Refresh();
 }
Beispiel #10
0
 /// <summary>
 /// Sets the filter.
 /// </summary>
 /// <param name="filter">The filter.</param>
 public void SetFilter(Predicate <object> filter)
 {
     PagedCollectionView.Filter = filter;
     PagedCollectionView.Refresh();
 }