From 23f0408fd405e2f00c6434dffdfe4fcd5cd953d8 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 2 Aug 2018 15:24:14 -0400 Subject: [PATCH] GridSettings\Sounds - add PropertyWrapperVM functional utils for reusable simple viewmodel templates --- .../core/Collections/KeyedItemSelector.cs | 237 ++++++++++++++++ .../spark/core/Utility/IPropertyWrapperVM.cs | 261 +++++++++++++++++- 2 files changed, 494 insertions(+), 4 deletions(-) create mode 100644 src/client/spark/core/Collections/KeyedItemSelector.cs diff --git a/src/client/spark/core/Collections/KeyedItemSelector.cs b/src/client/spark/core/Collections/KeyedItemSelector.cs new file mode 100644 index 000000000..116d73b83 --- /dev/null +++ b/src/client/spark/core/Collections/KeyedItemSelector.cs @@ -0,0 +1,237 @@ +using mbts.ui.shell; +using mbts.ui.utility; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.Linq; + +namespace mbts.collections { + class ItemSelector : ViewModelBase { + readonly IEqualityComparer _eq_comparer; + readonly IRaiseNotifyPropertyChanged _owner; + readonly Property _value; + readonly string _prop_name; + bool _waiting_to_select_desired_item; + T _desired_value; + + public ItemSelector(IRaiseNotifyPropertyChanged owner, string prop_name, IObservableCollection items) + : this(owner, prop_name, items, EqualityComparer.Default) { } + + public ItemSelector(IRaiseNotifyPropertyChanged owner, string prop_name, IObservableCollection items, IEqualityComparer eq_comparer) { + _owner = owner; + _prop_name = prop_name; + _eq_comparer = eq_comparer; + this.items = items; + _value = backing(nameof(value)); + if (items.Count > 0) + _value.set(items[0]); + else { + items.CollectionChanged += select_first_item_callback; + void select_first_item_callback(object sender, NotifyCollectionChangedEventArgs e) { + if (_waiting_to_select_desired_item) { + items.CollectionChanged -= select_first_item_callback; + } else if (e.NewItems != null) { + _value.set(e.NewItems.OfType().FirstOrDefault()); + items.CollectionChanged -= select_first_item_callback; + } + } + } + } + + + public IObservableCollection items { get; } + public T value { + get => _value.Value; + set { + _value.set(value); + if (_waiting_to_select_desired_item) { + items.CollectionChanged -= _on_items_CollectionChanged; + _waiting_to_select_desired_item = false; + } + _owner.raise_notify_property_changed(_prop_name); + } + } + + public bool try_select(T value) { + if (items.Contains(value)) { + this.value = value; + return true; + } else { + if (!_waiting_to_select_desired_item) { + items.CollectionChanged += _on_items_CollectionChanged; + _waiting_to_select_desired_item = true; + } + _desired_value = value; + return false; + } + } + + void _on_items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { + if (e.NewItems != null) { + foreach (T i in e.NewItems) + if (_eq_comparer.Equals(i, _desired_value)) { + value = i; + return; + } + } + } + } + + class MultiItemSelector : ViewModelBase { + readonly IEqualityComparer _eq_comparer; + HashSet _desired_items; + + public MultiItemSelector(IObservableCollection items) + : this (items, EqualityComparer.Default) { } + + public MultiItemSelector(IObservableCollection items, IEqualityComparer eq_comparer) { + this.items = items; + _eq_comparer = eq_comparer; + _desired_items = new HashSet(eq_comparer); + } + + public IObservableCollection items { get; } + public ObservableCollection selected_items { get; } = new ObservableCollection(); + + public bool try_select(T value) { + if (items.Contains(value)) { + selected_items.Add(value); + return true; + } else { + if (_desired_items.Count == 0) { + items.CollectionChanged += _on_items_CollectionChanged; + } + _desired_items.Add(value); + return false; + } + } + + void _on_items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { + switch (e.Action) { + case NotifyCollectionChangedAction.Add: + case NotifyCollectionChangedAction.Replace: + foreach (T i in e.NewItems) + if (_desired_items.Remove(i)) { + selected_items.Add(i); + } + if (_desired_items.Count == 0) + items.CollectionChanged -= _on_items_CollectionChanged; + break; + } + } + } + + + class KeyedItemSelector : ViewModelBase where TKey : struct, IEquatable { + readonly IRaiseNotifyPropertyChanged _owner; + readonly Property _value; + readonly Func _key_selector; + readonly string _prop_name; + TKey? _desired_key; + + public KeyedItemSelector(IRaiseNotifyPropertyChanged owner, string prop_name, IObservableCollection items, Func key) { + _owner = owner; + _prop_name = prop_name; + this.items = items; + _key_selector = key; + _value = backing(nameof(value)); + } + + public IObservableCollection items { get; } + public T value { + get => _value.Value; + set { + _value.set(value); + if (_desired_key.HasValue) { + items.CollectionChanged -= _on_items_CollectionChanged; + _desired_key = null; + } + _owner.raise_notify_property_changed(_prop_name); + } + } + + public bool try_select(TKey key) { + if (items.TryGetFirst(i => _key_selector(i).Equals(key), out T result)) { + value = result; + return true; + } else { + if (!_desired_key.HasValue) { + items.CollectionChanged += _on_items_CollectionChanged; + } + _desired_key = key; + return false; + } + } + + void _on_items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { + switch (e.Action) { + case NotifyCollectionChangedAction.Add: + case NotifyCollectionChangedAction.Replace: + foreach (T i in e.NewItems) + if (_key_selector(i).Equals(_desired_key.Value)) { + value = i; + return; + } + break; + } + } + } + + class KeyedMultiSelector : ViewModelBase where TKey : struct, IEquatable { + readonly Func _key_selector; + HashSet _desired_keys = new HashSet(); + + public KeyedMultiSelector(IObservableCollection items, Func key) { + this.items = items; + _key_selector = key; + } + + public IObservableCollection items { get; } + public ObservableCollection selected_items { get; } = new ObservableCollection(); + public IEnumerable selected_keys => selected_items.Select(_key_selector); + + public bool try_select(TKey key) { + if (items.TryGetFirst(i => _key_selector(i).Equals(key), out T result)) { + selected_items.Add(result); + return true; + } else { + if (_desired_keys.Count == 0) { + items.CollectionChanged += _on_items_CollectionChanged; + } + _desired_keys.Add(key); + return false; + } + } + + void _on_items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { + switch (e.Action) { + case NotifyCollectionChangedAction.Add: + case NotifyCollectionChangedAction.Replace: + foreach (T i in e.NewItems) + if (_desired_keys.Remove(_key_selector(i))) { + selected_items.Add(i); + } + if (_desired_keys.Count == 0) + items.CollectionChanged -= _on_items_CollectionChanged; + break; + } + } + } + + static class KeyedSelectorExtensions { + public static bool? try_select(this KeyedMultiSelector selector, IEnumerable keys) where TKey : struct, IEquatable { + int n_selected = 0, n_total = 0; + foreach (TKey k in keys) { + if (selector.try_select(k)) + n_selected++; + n_total++; + } + if (n_total == n_selected) { + return true; + } else if (n_selected == 0) { + return false; + } else return null; + } + } +} \ No newline at end of file diff --git a/src/client/spark/core/Utility/IPropertyWrapperVM.cs b/src/client/spark/core/Utility/IPropertyWrapperVM.cs index 1bec6b59d..3a8d85d27 100644 --- a/src/client/spark/core/Utility/IPropertyWrapperVM.cs +++ b/src/client/spark/core/Utility/IPropertyWrapperVM.cs @@ -1,8 +1,261 @@ -namespace mbts.spark -{ - interface IPropertyWrapperVM - { +using mbts.collections; +using mbts.ui; +using mbts.ui.shell; +using mbts.ui.utility; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Reactive.Linq; +using System.Runtime.CompilerServices; + +namespace mbts.spark { + interface IPropertyWrapperVM { void assign_to(TMutable value); void load_from(TImmutable value); } + + interface IPropertyWrapperVM { + void assign_to(T value); + void load_from(T value); + } + + interface IImmutablePropertyWrapperVM { + TSource update_source(TSource curr, TValue value); + void load_from(TValue value); + } + + interface IValueFactory { + T create(); + void load_from(T value); + } + + interface IViewValue { + object value { get; } + object view { get; } + } + + interface IViewValue : IViewValue { + new T value { get; } + } + + class ViewValueTuple : IViewValue { + public ViewValueTuple(TValue value, object view) { + this.value = value; + this.view = view; + } + + public TValue value { get; } + public object view { get; } + object IViewValue.value => value; + + public override string ToString() => value.ToString(); + } + + interface ITemplatedPropertyWrapperVM : IPropertyWrapperVM, ITemplateSelectorKey { } + + static class PropertyWrapperVMUtils { + public static T create_assigned(this IPropertyWrapperVM vm) where T : new() => + vm.create_assigned(() => new T()); + + public static T create_assigned(this IPropertyWrapperVM vm, Func create_new) { + var rv = create_new(); + vm.assign_to(rv); + return rv; + } + + public static TVM init_vm(T value) where TVM : IPropertyWrapperVM, new() { + var vm = new TVM(); + vm.load_from(value); + return vm; + } + + public static ITemplatedPropertyWrapperVM create_vm(string template_key, Func get, Action set, Dictionary> named_params = null) => + new DelegatePropertyWrapperVM(template_key, get, set, named_params); + + public static ITemplatedPropertyWrapperVM create_selector_vm(string template_key, IObservableCollection items, Func get, Action set) => + new SingleItemSelectorVM(template_key, items, get, set); + + public static ITemplatedPropertyWrapperVM create_keyed_selector_vm(string template_key, IObservableCollection items, Func get, Action set, Func key) + where TKey : struct, IEquatable => new SingleKeyedItemSelectorVM(template_key, items, get, set, key); + + public static ITemplatedPropertyWrapperVM create_multi_selector_vm(string template_key, IObservableCollection items, Func> get, Action> set) => + new MultiItemSelectorVM(template_key, items, get, set); + + public static ITemplatedPropertyWrapperVM create_keyed_multi_selector_vm(string template_key, IObservableCollection items, Func> get, Action> set, Func key) + where TKey : struct, IEquatable => new MultiKeyedItemSelectorVM(template_key, items, get, set, key); + + public static IPropertyWrapperVM link(this IPropertyWrapperVM inner, Func get, Action set) => + new LinkedPropertyWrapperVM(inner, get, set); + + class LinkedPropertyWrapperVM : ViewModelBase, IPropertyWrapperVM { + readonly Func _get; + readonly Action _set; + + public LinkedPropertyWrapperVM(IPropertyWrapperVM inner, Func get, Action set) { + _get = get; + _set = set; + value = inner; + } + + public IPropertyWrapperVM value { get; } + + public void assign_to(TOutter value) { + TInner inner_val = _get(value); + this.value.assign_to(inner_val); + _set(value, inner_val); + } + public void load_from(TOutter value) { + TInner inner_val = _get(value); + this.value.load_from(inner_val); + } + } + + class DelegatePropertyWrapperVM : DisposableViewModelBase, ITemplatedPropertyWrapperVM { + readonly Func _get; + readonly Action _set; + readonly Property _value; + readonly string _template_key; + readonly Dictionary _named_params = new Dictionary(); + + public DelegatePropertyWrapperVM(string template_key, Func get, Action set, Dictionary> named_params = null) { + _template_key = template_key; + _get = get; + _set = set; + _value = backing(nameof(value)); + if (!named_params.is_null_or_empty()) { + _dispose = Disposable.Create(named_params.Select(kv => + kv.Value.OnDispatcher().Subscribe(v => { + _named_params[kv.Key] = v; + // unf the only way to notify the view that an indexed prop has changed + // is to fire PropertyChanged with the hard-coded string below, which causes all indexed property bindings to update. + RaisePropertyChanged("Item[]"); + })).ToArray()); + } + } + + public TValue value { get => _value.Value; set => this._value.set(value); } + public IReadOnlyDictionary named_params { get; } + string ITemplateSelectorKey.key => _template_key; + + //https://stackoverflow.com/questions/657675/propertychanged-for-indexer-property + [IndexerName("Item")] + public object this[string name] => _named_params.TryGetValue(name, out object result) ? result : null; + + public void assign_to(T source) => _set(source, value); + public void load_from(T source) => _value.set(_get(source)); + } + + class ItemsPropertyWrapperVM : ViewModelBase, ITemplatedPropertyWrapperVM { + readonly Func> _get; + readonly Action> _set; + readonly string _template_key; + + public ItemsPropertyWrapperVM(string template_key, Func> get, Action> set) { + _template_key = template_key; + _get = get; + _set = set; + } + + public ObservableCollection value { get; } = new ObservableCollection(); + string ITemplateSelectorKey.key => _template_key; + + public void assign_to(T source) => _set(source, value); + public void load_from(T source) => value.sync_with(_get(source)); + } + + class MultiItemSelectorVM : ViewModelBase, ITemplatedPropertyWrapperVM { + readonly Func> _get; + readonly Action> _set; + readonly MultiItemSelector _selector; + readonly string _template_key; + + public MultiItemSelectorVM(string template_key, IObservableCollection items, Func> get, Action> set) { + _template_key = template_key; + _get = get; + _set = set; + _selector = new MultiItemSelector(items); + } + + public ObservableCollection value => _selector.selected_items; + public IObservableCollection items => _selector.items; + string ITemplateSelectorKey.key => _template_key; + + public void assign_to(T source) => _set(source, value); + public void load_from(T source) { + var desired_selection = new HashSet(_get(source)); + desired_selection.ExceptWith(value); + value.RemoveAll(v => !desired_selection.Contains(v)); + foreach (TValue v in desired_selection) + _selector.try_select(v); + } + } + + class SingleItemSelectorVM : ViewModelBase, ITemplatedPropertyWrapperVM { + readonly Func _get; + readonly Action _set; + readonly ItemSelector _selector; + readonly string _template_key; + + public SingleItemSelectorVM(string template_key, IObservableCollection items, Func get, Action set) { + _template_key = template_key; + _get = get; + _set = set; + _selector = new ItemSelector(this, nameof(value), items); + } + + public TValue value { get => _selector.value; set => _selector.value = value; } + public IObservableCollection items => _selector.items; + string ITemplateSelectorKey.key => _template_key; + + public void assign_to(T source) => _set(source, value); + public void load_from(T source) => _selector.try_select(_get(source)); + } + + class SingleKeyedItemSelectorVM : ViewModelBase, ITemplatedPropertyWrapperVM where TKey : struct, IEquatable { + readonly Func _get; + readonly Action _set; + readonly Func _key; + readonly KeyedItemSelector _selector; + readonly string _template_key; + + public SingleKeyedItemSelectorVM(string template_key, IObservableCollection items, Func get, Action set, Func key) { + _template_key = template_key; + _get = get; + _set = set; + _key = key; + _selector = new KeyedItemSelector(this, nameof(value), items, key); + } + + public TValue value { get => _selector.value; set => _selector.value = value; } + public IObservableCollection items => _selector.items; + string ITemplateSelectorKey.key => _template_key; + + public void assign_to(T source) => _set(source, _key(value)); + public void load_from(T source) => _selector.try_select(_get(source)); + } + + class MultiKeyedItemSelectorVM : ViewModelBase, ITemplatedPropertyWrapperVM where TKey : struct, IEquatable { + readonly Func> _get; + readonly Action> _set; + readonly Func _key; + readonly KeyedMultiSelector _selector; + readonly string _template_key; + + public MultiKeyedItemSelectorVM(string template_key, IObservableCollection items, Func> get, Action> set, Func key) { + _template_key = template_key; + _get = get; + _set = set; + _key = key; + _selector = new KeyedMultiSelector(items, key); + } + + public ObservableCollection value => _selector.selected_items; + public IObservableCollection items => _selector.items; + string ITemplateSelectorKey.key => _template_key; + + public void assign_to(T source) => _set(source, value.Select(_key)); + public void load_from(T source) => _selector.try_select(_get(source)); + } + } } \ No newline at end of file