Esempio n. 1
0
 private void Collection_WrappedValueChanged(object sender, WrappedValueChangedEventArgs e)
 {
     if (_filter == null)
     {
         return;
     }
     _observableCollection.RefreshFilter((AcItemWrapper)sender);
 }
Esempio n. 2
0
 private void OnWrapperValueChanged(object sender, WrappedValueChangedEventArgs e)
 {
     if (ListFilter != null)
     {
         RefreshFilter((AcItemWrapper)sender);
         MainListUpdated();
     }
     else if (_grouped && _collectionReady)
     {
         _list.RefreshFilter((AcItemWrapper)sender);
     }
 }
Esempio n. 3
0
        void OnListWrappedValueChanged(object sender, WrappedValueChangedEventArgs e)
        {
            var car = e.NewValue as CarObject;

            if (car == null || SelectedCar == null)
            {
                return;
            }

            if (car.ParentId == SelectedCar.Id)
            {
                _previousTunableParent = null;
                UpdateTunableVersions();
            }
        }
Esempio n. 4
0
            private void Wrapper_ValueChanged(object sender, WrappedValueChangedEventArgs args)
            {
                WeakEventManager <INotifyPropertyChanged, PropertyChangedEventArgs> .RemoveHandler(args.OldValue, nameof(INotifyPropertyChanged.PropertyChanged),
                                                                                                   Value_PropertyChanged);

                var wrapper = (AcItemWrapper)sender;

                if (wrapper.IsLoaded)
                {
                    WeakEventManager <INotifyPropertyChanged, PropertyChangedEventArgs> .AddHandler(args.NewValue, nameof(INotifyPropertyChanged.PropertyChanged),
                                                                                                    Value_PropertyChanged);
                }

                _text.Text = args.NewValue.DisplayName;
            }
Esempio n. 5
0
        private void Collection_WrappedValueChanged(object sender, WrappedValueChangedEventArgs e)
        {
            var o = e.OldValue as T;

            if (o != null)
            {
                Remove(o);
            }

            var n = e.NewValue as T;

            if (n?.Enabled != true)
            {
                return;
            }

            var i = _collection.FindIndex(x => x.Value == n);

            if (i == -1 || i == _collection.Count - 1)
            {
                Add(n);
                return;
            }

            var after = _collection.Take(i).LastOrDefault(x => x.IsLoaded && x.Value.Enabled);

            if (after == null)
            {
                Insert(0, n);
                return;
            }

            var afterLocal = Items.IndexOf(after.Value);

            if (afterLocal == -1 || afterLocal == Items.Count - 1)
            {
                Add(n);
                return;
            }

            Insert(afterLocal + 1, n);
        }
Esempio n. 6
0
        private void WrappersList_WrappedValueChanged(object sender, WrappedValueChangedEventArgs args)
        {
            var newValue = args.NewValue as TObject;
            var oldValue = args.OldValue as TObject;

            if (newValue != null)
            {
                if (oldValue != null)
                {
                    UpdateIfNeeded();
                }
                else if (newValue.Enabled)
                {
                    AddNewIfMissing(_items, newValue);
                }
            }
            else if (oldValue != null)
            {
                UpdateIfNeeded();
            }
        }
Esempio n. 7
0
 private void OnWrappedValueChanged(object sender, WrappedValueChangedEventArgs e)
 {
     _wrapped.Refresh((AcItemWrapper)sender);
 }
 private void List_WrapperValueChanged(object sender, WrappedValueChangedEventArgs e)
 {
     RefreshFilter((AcItemWrapper)sender);
     MainListUpdated();
 }
Esempio n. 9
0
 private void Item_ValueChanged(object sender, WrappedValueChangedEventArgs e)
 {
     e.OldValue.PropertyChanged -= Item_PropertyChanged;
     e.NewValue.PropertyChanged += Item_PropertyChanged;
     WrappedValueChanged?.Invoke(sender, e);
 }