Esempio n. 1
0
        private void Add_Click(object sender, RoutedEventArgs e)
        {
            int chosenMovement = (int)ChosenMovement.SelectedValue;
            int from           = Misc.FromMask(FromYear.Text, int.MinValue);
            int to             = Misc.FromMask(ToYear.Text, int.MaxValue);
            var func1          = new Func <Painting, bool>(x => true);
            var func2          = new Func <Painting, bool>(x => true);

            if (MovementChoiceCheckBox.IsChecked == true)
            {
                func1 = (s) => s.art_movement_id == chosenMovement;
            }
            if (YearChoiceCheckBox.IsChecked == true)
            {
                func2 = (s) => s.year_of_creation >= from && s.year_of_creation <= to;
            }
            FilterEventHandler handler = (s, ee) =>
            {
                var painting = ee.Item as Painting;
                ee.Accepted = func1(painting) && func2(painting);
            };

            Filters.Filter += handler;
            ListOfFilters.Items.Add(FilterName.Text);
            Delegates.Add(FilterName.Text, handler);
            FilterName.Text = NameGenerator.GenerateName(ListOfFilters.Items, "Фильтр");
            FromYear.Text   = "*";
            ToYear.Text     = "*";
            ChosenMovement.SelectedIndex     = 0;
            MovementChoiceCheckBox.IsChecked = false;
            YearChoiceCheckBox.IsChecked     = false;
        }
Esempio n. 2
0
        /// <summary>
        /// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
        /// <example>
        /// filtereventhandler.BeginInvoke(sender, e, callback);
        /// </example>
        /// </summary>
        public static IAsyncResult BeginInvoke(this FilterEventHandler filtereventhandler, Object sender, FilterEventArgs e, AsyncCallback callback)
        {
            if (filtereventhandler == null)
            {
                throw new ArgumentNullException("filtereventhandler");
            }

            return(filtereventhandler.BeginInvoke(sender, e, callback, null));
        }
        /// <summary>
        /// 触发过虑事件
        /// </summary>
        /// <param name="e">事件参数</param>
        protected virtual void OnFilter(FilterEventArgs <TEntity> e)
        {
            FilterEventHandler <TEntity> handler = Filter;

            if (handler != null)
            {
                handler(this, e);
            }
        }
Esempio n. 4
0
        private void CmbFilter_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            bool isInStartList(RunResult rr)
            {
                return(this._currentRaceRun.GetStartListProvider().GetViewList().FirstOrDefault(p => p.Participant == rr.Participant) != null);
            }

            if (_viewDisqualificationsFilterHandler != null)
            {
                _viewDisqualifications.Filter -= _viewDisqualificationsFilterHandler;
            }

            if (cmbFilter.SelectedItem is CBItem selected)
            {
                _viewDisqualificationsFilterHandler = null;
                if (string.Equals(selected.Value, "all"))
                {
                    _viewDisqualificationsFilterHandler = new FilterEventHandler(
                        delegate(object s, FilterEventArgs ea)
                    {
                        RunResult rr = (RunResult)ea.Item; ea.Accepted = isInStartList(rr);
                    });
                }
                else if (string.Equals(selected.Value, "no_time"))
                {
                    _viewDisqualificationsFilterHandler = new FilterEventHandler(
                        delegate(object s, FilterEventArgs ea)
                    {
                        RunResult rr = (RunResult)ea.Item; ea.Accepted = isInStartList(rr) && rr.RuntimeWOResultCode == null;
                    });
                }
                else if (string.Equals(selected.Value, "out"))
                {
                    _viewDisqualificationsFilterHandler = new FilterEventHandler(
                        delegate(object s, FilterEventArgs ea)
                    {
                        RunResult rr = (RunResult)ea.Item; ea.Accepted = isInStartList(rr) && (rr.ResultCode != RunResult.EResultCode.Normal && rr.ResultCode != RunResult.EResultCode.NotSet);
                    });
                }
                else if (string.Equals(selected.Value, "no_data"))
                {
                    _viewDisqualificationsFilterHandler = new FilterEventHandler(
                        delegate(object s, FilterEventArgs ea)
                    {
                        RunResult rr = (RunResult)ea.Item; ea.Accepted = isInStartList(rr) && rr.ResultCode == RunResult.EResultCode.NotSet;
                    });
                }
            }

            if (_viewDisqualificationsFilterHandler != null)
            {
                _viewDisqualifications.Filter += _viewDisqualificationsFilterHandler;
            }

            _viewDisqualifications.View.Refresh();
        }
        private bool WrapFilter(object item)
        {
            FilterEventArgs    filterEventArg     = new FilterEventArgs(item);
            FilterEventHandler filterEventHandler = this.filterHandlers;

            if (filterEventHandler != null)
            {
                filterEventHandler(this, filterEventArg);
            }
            return(filterEventArg.Accepted);
        }
Esempio n. 6
0
        private bool WrapFilter(object item)
        {
            FilterEventArgs    args     = new FilterEventArgs(item);
            FilterEventHandler handlers = _filterHandlers;

            if (handlers != null)
            {
                handlers(this, args);
            }

            return(args.Accepted);
        }
Esempio n. 7
0
 private void SetFilter(object sender, FilterEventHandler filter)
 {
     if (((RadioButton)sender).IsChecked == true)
     {
         _collectionViewSource.Filter += filter;
         SearchTxt.Text = String.Empty;
     }
     else
     {
         _collectionViewSource.Filter -= filter;
     }
 }
Esempio n. 8
0
        bool WrapFilter(object item)
        {
            FilterEventArgs    args     = new FilterEventArgs(item);
            FilterEventHandler handlers = FilterHandlersField.GetValue(this);

            if (handlers != null)
            {
                handlers(this, args);
            }

            return(args.Accepted);
        }
Esempio n. 9
0
        public void FilterUsedImmediately()
        {
            bool called          = false;
            FilterEventHandler h = (o, e) => { called = true; };

            var source = new CollectionViewSource {
                Source = this.Source
            };

            source.Filter += h;

            Assert.IsTrue(called, "#1");
        }
Esempio n. 10
0
 private void SetFilter(object sender, FilterEventHandler filter)
 {
     SetContext(_db.GetAll());
     if (((RadioButton)sender).IsChecked == true)
     {
         _collectionViewSource.Filter += filter;
         SearchTxt.Text = String.Empty;
     }
     else
     {
         _collectionViewSource.Filter -= filter;
     }
     RefreshList();
 }
Esempio n. 11
0
        private void Add_Click(object sender, RoutedEventArgs e)
        {
            int yearFrom = Misc.FromMask(FromYear.Text, int.MinValue);
            int yearTo   = Misc.FromMask(FromYear.Text, int.MinValue);

            int widthFrom  = Misc.FromMask(WidthFrom.Text, int.MinValue);
            int widthTo    = Misc.FromMask(WidthTo.Text, int.MinValue);
            int heightFrom = Misc.FromMask(HeightFrom.Text, int.MinValue);
            int heightTo   = Misc.FromMask(HeightTo.Text, int.MinValue);

            bool shouldBeOriginal = Original.IsChecked.Value;

            Predicate <Exhibit> checkOriginal = (x) => true;
            Predicate <Exhibit> checkYear     = (x) => true;
            Predicate <Exhibit> checkSize     = (x) => true;

            if (IsOriginalChoiceCheckBox.IsChecked == true)
            {
                checkOriginal = (x) => x.is_original == shouldBeOriginal;
            }
            if (YearChoiceCheckBox.IsChecked == true)
            {
                checkYear = (x) => x.date_of_acquiring.Year >= yearFrom && x.date_of_acquiring.Year <= yearTo;
            }
            if (SizeChoiceCheckBox.IsChecked == true)
            {
                checkSize = (x) => x.width >= widthFrom && x.width <= widthTo && x.height >= heightFrom && x.height <= heightTo;
            }
            FilterEventHandler handler = (s, ee) =>
            {
                var exhibit = ee.Item as Exhibit;
                ee.Accepted = checkOriginal(exhibit) && checkYear(exhibit) && checkSize(exhibit);
            };

            Filters.Filter += handler;
            Delegates.Add(FilterName.Text, handler);
            ListOfFilters.Items.Add(FilterName.Text);
            FilterName.Text    = NameGenerator.GenerateName(ListOfFilters.Items, "Фильтр");
            Original.IsChecked = true;
            FromYear.Text      = "*";
            ToYear.Text        = "*";
            WidthFrom.Text     = "*";
            WidthTo.Text       = "*";
            HeightFrom.Text    = "*";
            HeightTo.Text      = "*";
            IsOriginalChoiceCheckBox.IsChecked = false;
            SizeChoiceCheckBox.IsChecked       = false;
            YearChoiceCheckBox.IsChecked       = false;
        }
Esempio n. 12
0
        public void SourceFilterIsPropagated()
        {
            FilterEventHandler h = (o, e) => { };
            var source           = new CollectionViewSource {
                Source = this.Source
            };

            Assert.IsNull(source.View.Filter, "#1");

            source.Filter += h;
            Assert.IsNotNull(source.View.Filter, "#2");

            source.Filter -= h;
            Assert.IsNull(source.View.Filter, "#3");
        }
        private void txtSearch_TextChanged(object sender, TextChangedEventArgs e)
        {
            Application.Current.Dispatcher.Invoke(() =>
            {
                if (_viewParticipantsFilterHandler != null)
                {
                    _viewParticipants.Filter -= _viewParticipantsFilterHandler;
                }

                string sFilter = txtSearch.Text;

                _viewParticipantsFilterHandler = null;
                if (!string.IsNullOrEmpty(sFilter))
                {
                    _viewParticipantsFilterHandler = new FilterEventHandler(delegate(object s, FilterEventArgs ea)
                    {
                        bool contains(string bigString, string part)
                        {
                            if (string.IsNullOrEmpty(bigString))
                            {
                                return(false);
                            }

                            return(System.Threading.Thread.CurrentThread.CurrentCulture.CompareInfo.IndexOf(bigString, part, CompareOptions.IgnoreCase) >= 0);
                        }

                        ParticipantEdit p = (ParticipantEdit)ea.Item;

                        ea.Accepted =
                            contains(p.Name, sFilter) ||
                            contains(p.Firstname, sFilter) ||
                            contains(p.Club, sFilter) ||
                            contains(p.Nation, sFilter) ||
                            contains(p.Year.ToString(), sFilter) ||
                            contains(p.Code, sFilter) ||
                            contains(p.SvId, sFilter) ||
                            contains(p.Class?.ToString(), sFilter) ||
                            contains(p.Group?.ToString(), sFilter);
                    });
                }
                if (_viewParticipantsFilterHandler != null)
                {
                    _viewParticipants.Filter += _viewParticipantsFilterHandler;
                }

                _viewParticipants.View.Refresh();
            });
        }
Esempio n. 14
0
        /*--- Method: private -----------------------------------------------------------------------------------------------------------------------------------------*/

        /// <summary> フィルタの設定/解除を実行します。
        /// </summary>
        /// <param name="pCollectionViewSource"> フィルタ設定するCollectionViewSource </param>
        /// <param name="pFilter"> 対象フィルタ </param>
        /// <param name="pAccepted"> フィルタ追加する場合は False, フィルタ解除する場合は True </param>
        private void ascceptedFilter(CollectionViewSource pCollectionViewSource, FilterEventHandler pFilter, bool pAccepted)
        {
            if (!pAccepted)
            {
                pCollectionViewSource.Filter += pFilter;
            }
            else
            {
                pCollectionViewSource.Filter -= pFilter;
            }

            if (pCollectionViewSource.View != null)
            {
                pCollectionViewSource.View.Refresh();
            }
        }
Esempio n. 15
0
        /// <summary> TimelineTypeによるフィルタを設定します。
        /// <para> * pAccepted のboolに注意すること。意味が逆になってる。 </para>
        /// </summary>
        /// <param name="pCollectionViewSource"> フィルタ設定するCollectionViewSource </param>
        /// <param name="pTimelineType"> 設定対象のTimelineType </param>
        /// <param name="pAccepted"> フィルタ追加する場合は False, フィルタ解除する場合は True </param>
        public void SetTimelineTypeFilter(CollectionViewSource pCollectionViewSource, TimelineType pTimelineType, bool pAccepted)
        {
            FilterEventHandler filter = null;

            switch (pTimelineType)
            {
            case TimelineType.UNKNOWN:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypeUNKNOWN);
                break;

            case TimelineType.ENEMY:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypeENEMY);
                break;

            case TimelineType.TANK:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypeTANK);
                break;

            case TimelineType.DPS:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypeDPS);
                break;

            case TimelineType.HEALER:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypeHEALER);
                break;

            case TimelineType.PET:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypePET);
                break;

            case TimelineType.GIMMICK:
                filter = new FilterEventHandler(this.typeFilter.Filter_TypeGIMMICK);
                break;

            default:
                return;
            }

            if (filter == null)
            {
                return;
            }

            this.ascceptedFilter(pCollectionViewSource, filter, pAccepted);

            return;
        }
Esempio n. 16
0
        private void Add_Click(object sender, RoutedEventArgs e)
        {
            int from = Misc.FromMask(FromYear.Text, int.MinValue);
            int to   = Misc.FromMask(ToYear.Text, int.MaxValue);
            FilterEventHandler handler = (s, ee) =>
            {
                var art = ee.Item as Artist;
                ee.Accepted = art.date_of_birth.Value.Year >= from && art.date_of_death.Value.Year <= to;
            };

            Filters.Filter += handler;
            ListOfFilters.Items.Add(FilterName.Text);
            Delegates.Add(FilterName.Text, handler);
            FilterName.Text = NameGenerator.GenerateName(ListOfFilters.Items, "Фильтр");
            FromYear.Text   = "*";
            ToYear.Text     = "*";
        }
Esempio n. 17
0
        private void HandleDatePickerFilterChange(DatePicker datePicker,
                                                  FilterEventHandler filter, FilterType filterType, SelectionChangedEventArgs e)
        {
            GUIServices.SetBusyState();

            if (e.RemovedItems.Count == 0)
            {
                AddFilter(filter, filterType);
                return;
            }

            if (datePicker.SelectedDate == null)
            {
                RemoveFilter(filterType);
            }

            RefreshView();
        }
Esempio n. 18
0
        private void HandleListBoxFilterChange(ListBox listBox,
                                               FilterEventHandler filter, FilterType filterType, SelectionChangedEventArgs e)
        {
            GUIServices.SetBusyState();

            if (listBox.SelectedItems.Count == 1 && e.AddedItems.Count == 1)
            {
                AddFilter(filter, filterType);
                return;
            }

            if (listBox.SelectedItems.Count == 0)
            {
                RemoveFilter(filterType);
            }

            RefreshView();
        }
Esempio n. 19
0
        private void HandleComboBoxFilterChange(ComboBox comboBox,
                                                FilterEventHandler filter, FilterType filterType, SelectionChangedEventArgs e)
        {
            GUIServices.SetBusyState();

            if (e.RemovedItems.Count == 0)
            {
                AddFilter(filter, filterType);
                return;
            }

            if (comboBox.SelectedIndex == -1)
            {
                RemoveFilter(filterType);
            }

            RefreshView();
        }
Esempio n. 20
0
        private void HandleTextBoxFilterChange(
            TextBox textBox, FilterEventHandler filter, FilterType filterType)
        {
            GUIServices.SetBusyState();

            if (!_textFilters.Contains(filterType))
            {
                AddFilter(filter, filterType);
                _textFilters.Add(filterType);
                return;
            }

            if (textBox.Text == string.Empty)
            {
                RemoveFilter(filterType);
                _textFilters.Remove(filterType);
            }

            RefreshView();
        }
Esempio n. 21
0
        // Filter the data source using an event (the user sets e.Accepted to true or false in the event handler):
        void Filter(FilterEventHandler logicMethod)
        {
            // Create a new collection with the result of the filtering:
            Collection <object> childItems = new Collection <object>();

            foreach (object obj in Items)
            {
                FilterEventArgs args = new FilterEventArgs(obj);

                logicMethod(this, args);

                if (args.Accepted)
                {
                    childItems.Add(obj);
                }
            }

            // Pass the result of the filtering to a child CollectionViewGroup in order to apply other operations (such as sort) if any:
            INTERNAL_CollectionViewGroupInternal newView = new INTERNAL_CollectionViewGroupInternal(childItems, this, _operations);

            _operations.Requester.AddView(newView); // create child branch
        }
Esempio n. 22
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="Section" /> class.
        /// </summary>
        /// <param name="section">The section.</param>
        /// <param name="filter">The filter.</param>
        /// <exception cref="System.ArgumentNullException">section</exception>
        public Section(Section section, FilterEventHandler filter)
        {
            if (section == null)
            {
                throw new ArgumentNullException("section");
            }

            Name    = section.Name;
            Ordinal = section.Ordinal;

            EntriesView = new CollectionViewSource
            {
                Source = Entries
            };

            EntriesView.Filter += filter;

            var ordinalSort = new SortDescription("Ordinal", ListSortDirection.Ascending);
            var nameSort    = new SortDescription("Name", ListSortDirection.Ascending);

            EntriesView.SortDescriptions.Add(ordinalSort);
            EntriesView.SortDescriptions.Add(nameSort);
        }
Esempio n. 23
0
		void UpdateIncrementalSearch(TextBox textBox, CollectionViewSource collectionViewSource, ref FilterEventHandler oldFilter)
		{
			var text = textBox.Text.Split(' ', ' ');

			using (collectionViewSource.DeferRefresh())
			{
				FilterEventHandler newFilter = (sender2, e2) =>
					e2.Accepted = e2.Accepted && (!text.Any() || e2.Item.TypeMatch
					(
						(FollowManagerWindowViewModel.Follow _) => new[] { _.User.Name, _.User.FullName, _.User.Description },
						(User _) => new[] { _.Name, _.FullName, _.Description },
						_ => Enumerable.Empty<string>()
					)
					.Where(_ => _ != null)
					.Any(_ => text.All(_.Contains)));

				collectionViewSource.Filter += newFilter;

				if (oldFilter != null)
					collectionViewSource.Filter -= oldFilter;

				oldFilter = newFilter;
			}
		}
Esempio n. 24
0
 private void AddFilter(FilterEventHandler filter, FilterType filterType)
 {
     _filters[filterType]       = new FilterEventHandler(filter);
     EntitiesViewSource.Filter += _filters[filterType];
 }
        /* end of properties */


        /* constructor */

        public GeneralFilter(CollectionViewSource cvs, Action <object, FilterEventArgs> filterEventHandler)
        {
            _cvs = cvs;
            _filterEventHandler = new FilterEventHandler(filterEventHandler);
            RemoveFilterCommand = new RelayCommand(RemoveFilter);
        }
Esempio n. 26
0
        // Note: the user has two options for filtering: either by passing a predicate,
        // or by registering an event and setting e.Accepted to true or false in the
        // event handler.

        public FilterDescription(FilterEventHandler _filterUsingAndEvent)
        {
            FilterUsingAnEvent = _filterUsingAndEvent;
        }
 private void AddFilter(CollectionViewSource view, FilterEventHandler eventHandler)
 {
     view.Filter -= eventHandler;
     view.Filter += eventHandler;
 }
Esempio n. 28
0
        /// <summary> Jobによるフィルタを設定します。
        /// <para> * pAccepted のboolに注意すること。意味が逆になってる。 </para>
        /// </summary>
        /// <param name="pCollectionViewSource"> フィルタ設定するCollectionViewSource </param>
        /// <param name="pJob"> 設定対象のJob </param>
        /// <param name="pAccepted"> フィルタ追加する場合は False, フィルタ解除する場合は True </param>
        public void SetJobFilter(CollectionViewSource pCollectionViewSource, Job pJob, bool pAccepted)
        {
            FilterEventHandler filter = null;

            switch (pJob)
            {
            case Job.UNKNOWN:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobUNKNOWN);
                break;

            case Job.NON:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobNON);
                break;

            case Job.PLD:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobPLD);
                break;

            case Job.WAR:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobWAR);
                break;

            case Job.DKN:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobDKN);
                break;

            case Job.MNK:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobMNK);
                break;

            case Job.DRG:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobDRG);
                break;

            case Job.BRD:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobBRD);
                break;

            case Job.NIN:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobNIN);
                break;

            case Job.BLM:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobBLM);
                break;

            case Job.SMN:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobSMN);
                break;

            case Job.MCN:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobMCN);
                break;

            case Job.WHM:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobWHM);
                break;

            case Job.SCH:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobSCH);
                break;

            case Job.AST:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobAST);
                break;

            case Job.EGI:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobEGI);
                break;

            case Job.FAIRY:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobFAIRY);
                break;

            case Job.TURRET:
                filter = new FilterEventHandler(this.jobFilter.Filter_JobTURRET);
                break;

            default:
                return;
            }

            if (filter == null)
            {
                return;
            }

            this.ascceptedFilter(pCollectionViewSource, filter, pAccepted);

            return;
        }