GridSettings\Sounds - add PropertyWrapperVM functional utils for reusable simple viewmodel templates

This commit is contained in:
John Colvin committed 2018-08-14 17:14:36 -04:00
1 parent f85b10a7df
commit 23f0408fd4
2 files changed
+494 -4

No files matched your search

@@ -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<T> : ViewModelBase {
readonly IEqualityComparer<T> _eq_comparer;
readonly IRaiseNotifyPropertyChanged _owner;
readonly Property<T> _value;
readonly string _prop_name;
bool _waiting_to_select_desired_item;
T _desired_value;
public ItemSelector(IRaiseNotifyPropertyChanged owner, string prop_name, IObservableCollection<T> items)
: this(owner, prop_name, items, EqualityComparer<T>.Default) { }
public ItemSelector(IRaiseNotifyPropertyChanged owner, string prop_name, IObservableCollection<T> items, IEqualityComparer<T> eq_comparer) {
_owner = owner;
_prop_name = prop_name;
_eq_comparer = eq_comparer;
this.items = items;
_value = backing<T>(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<T>().FirstOrDefault());
items.CollectionChanged -= select_first_item_callback;
}
}
}
}
public IObservableCollection<T> 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<T> : ViewModelBase {
readonly IEqualityComparer<T> _eq_comparer;
HashSet<T> _desired_items;
public MultiItemSelector(IObservableCollection<T> items)
: this (items, EqualityComparer<T>.Default) { }
public MultiItemSelector(IObservableCollection<T> items, IEqualityComparer<T> eq_comparer) {
this.items = items;
_eq_comparer = eq_comparer;
_desired_items = new HashSet<T>(eq_comparer);
}
public IObservableCollection<T> items { get; }
public ObservableCollection<T> selected_items { get; } = new ObservableCollection<T>();
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<T, TKey> : ViewModelBase where TKey : struct, IEquatable<TKey> {
readonly IRaiseNotifyPropertyChanged _owner;
readonly Property<T> _value;
readonly Func<T, TKey> _key_selector;
readonly string _prop_name;
TKey? _desired_key;
public KeyedItemSelector(IRaiseNotifyPropertyChanged owner, string prop_name, IObservableCollection<T> items, Func<T, TKey> key) {
_owner = owner;
_prop_name = prop_name;
this.items = items;
_key_selector = key;
_value = backing<T>(nameof(value));
}
public IObservableCollection<T> 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<T, TKey> : ViewModelBase where TKey : struct, IEquatable<TKey> {
readonly Func<T, TKey> _key_selector;
HashSet<TKey> _desired_keys = new HashSet<TKey>();
public KeyedMultiSelector(IObservableCollection<T> items, Func<T, TKey> key) {
this.items = items;
_key_selector = key;
}
public IObservableCollection<T> items { get; }
public ObservableCollection<T> selected_items { get; } = new ObservableCollection<T>();
public IEnumerable<TKey> 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<T, TKey>(this KeyedMultiSelector<T, TKey> selector, IEnumerable<TKey> keys) where TKey : struct, IEquatable<TKey> {
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;
}
}
}
@@ -1,8 +1,261 @@
namespace mbts.spark
{
interface IPropertyWrapperVM<in TMutable, in TImmutable>
{
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<in TMutable, in TImmutable> {
void assign_to(TMutable value);
void load_from(TImmutable value);
}
interface IPropertyWrapperVM<T> {
void assign_to(T value);
void load_from(T value);
}
interface IImmutablePropertyWrapperVM<TSource, TValue> {
TSource update_source(TSource curr, TValue value);
void load_from(TValue value);
}
interface IValueFactory<T> {
T create();
void load_from(T value);
}
interface IViewValue {
object value { get; }
object view { get; }
}
interface IViewValue<T> : IViewValue {
new T value { get; }
}
class ViewValueTuple<TValue> : IViewValue<TValue> {
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<T> : IPropertyWrapperVM<T>, ITemplateSelectorKey { }
static class PropertyWrapperVMUtils {
public static T create_assigned<T>(this IPropertyWrapperVM<T> vm) where T : new() =>
vm.create_assigned(() => new T());
public static T create_assigned<T>(this IPropertyWrapperVM<T> vm, Func<T> create_new) {
var rv = create_new();
vm.assign_to(rv);
return rv;
}
public static TVM init_vm<T, TVM>(T value) where TVM : IPropertyWrapperVM<T>, new() {
var vm = new TVM();
vm.load_from(value);
return vm;
}
public static ITemplatedPropertyWrapperVM<TSource> create_vm<TSource, TValue>(string template_key, Func<TSource, TValue> get, Action<TSource, TValue> set, Dictionary<string, IObservable<object>> named_params = null) =>
new DelegatePropertyWrapperVM<TSource, TValue>(template_key, get, set, named_params);
public static ITemplatedPropertyWrapperVM<TSource> create_selector_vm<TSource, TValue>(string template_key, IObservableCollection<TValue> items, Func<TSource, TValue> get, Action<TSource, TValue> set) =>
new SingleItemSelectorVM<TSource, TValue>(template_key, items, get, set);
public static ITemplatedPropertyWrapperVM<TSource> create_keyed_selector_vm<TSource, TValue, TKey>(string template_key, IObservableCollection<TValue> items, Func<TSource, TKey> get, Action<TSource, TKey> set, Func<TValue, TKey> key)
where TKey : struct, IEquatable<TKey> => new SingleKeyedItemSelectorVM<TSource, TValue, TKey>(template_key, items, get, set, key);
public static ITemplatedPropertyWrapperVM<TSource> create_multi_selector_vm<TSource, TValue>(string template_key, IObservableCollection<TValue> items, Func<TSource, IEnumerable<TValue>> get, Action<TSource, IEnumerable<TValue>> set) =>
new MultiItemSelectorVM<TSource, TValue>(template_key, items, get, set);
public static ITemplatedPropertyWrapperVM<TSource> create_keyed_multi_selector_vm<TSource, TValue, TKey>(string template_key, IObservableCollection<TValue> items, Func<TSource, IEnumerable<TKey>> get, Action<TSource, IEnumerable<TKey>> set, Func<TValue, TKey> key)
where TKey : struct, IEquatable<TKey> => new MultiKeyedItemSelectorVM<TSource, TValue, TKey>(template_key, items, get, set, key);
public static IPropertyWrapperVM<TOutter> link<TOutter, TInner>(this IPropertyWrapperVM<TInner> inner, Func<TOutter, TInner> get, Action<TOutter, TInner> set) =>
new LinkedPropertyWrapperVM<TOutter, TInner>(inner, get, set);
class LinkedPropertyWrapperVM<TOutter, TInner> : ViewModelBase, IPropertyWrapperVM<TOutter> {
readonly Func<TOutter, TInner> _get;
readonly Action<TOutter, TInner> _set;
public LinkedPropertyWrapperVM(IPropertyWrapperVM<TInner> inner, Func<TOutter, TInner> get, Action<TOutter, TInner> set) {
_get = get;
_set = set;
value = inner;
}
public IPropertyWrapperVM<TInner> 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<T, TValue> : DisposableViewModelBase, ITemplatedPropertyWrapperVM<T> {
readonly Func<T, TValue> _get;
readonly Action<T, TValue> _set;
readonly Property<TValue> _value;
readonly string _template_key;
readonly Dictionary<string, object> _named_params = new Dictionary<string, object>();
public DelegatePropertyWrapperVM(string template_key, Func<T, TValue> get, Action<T, TValue> set, Dictionary<string, IObservable<object>> named_params = null) {
_template_key = template_key;
_get = get;
_set = set;
_value = backing<TValue>(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<string, object> 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<T, TValue> : ViewModelBase, ITemplatedPropertyWrapperVM<T> {
readonly Func<T, IEnumerable<TValue>> _get;
readonly Action<T, IEnumerable<TValue>> _set;
readonly string _template_key;
public ItemsPropertyWrapperVM(string template_key, Func<T, IEnumerable<TValue>> get, Action<T, IEnumerable<TValue>> set) {
_template_key = template_key;
_get = get;
_set = set;
}
public ObservableCollection<TValue> value { get; } = new ObservableCollection<TValue>();
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<T, TValue> : ViewModelBase, ITemplatedPropertyWrapperVM<T> {
readonly Func<T, IEnumerable<TValue>> _get;
readonly Action<T, IEnumerable<TValue>> _set;
readonly MultiItemSelector<TValue> _selector;
readonly string _template_key;
public MultiItemSelectorVM(string template_key, IObservableCollection<TValue> items, Func<T, IEnumerable<TValue>> get, Action<T, IEnumerable<TValue>> set) {
_template_key = template_key;
_get = get;
_set = set;
_selector = new MultiItemSelector<TValue>(items);
}
public ObservableCollection<TValue> value => _selector.selected_items;
public IObservableCollection<TValue> 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<TValue>(_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<T, TValue> : ViewModelBase, ITemplatedPropertyWrapperVM<T> {
readonly Func<T, TValue> _get;
readonly Action<T, TValue> _set;
readonly ItemSelector<TValue> _selector;
readonly string _template_key;
public SingleItemSelectorVM(string template_key, IObservableCollection<TValue> items, Func<T, TValue> get, Action<T, TValue> set) {
_template_key = template_key;
_get = get;
_set = set;
_selector = new ItemSelector<TValue>(this, nameof(value), items);
}
public TValue value { get => _selector.value; set => _selector.value = value; }
public IObservableCollection<TValue> 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<T, TValue, TKey> : ViewModelBase, ITemplatedPropertyWrapperVM<T> where TKey : struct, IEquatable<TKey> {
readonly Func<T, TKey> _get;
readonly Action<T, TKey> _set;
readonly Func<TValue, TKey> _key;
readonly KeyedItemSelector<TValue, TKey> _selector;
readonly string _template_key;
public SingleKeyedItemSelectorVM(string template_key, IObservableCollection<TValue> items, Func<T, TKey> get, Action<T, TKey> set, Func<TValue, TKey> key) {
_template_key = template_key;
_get = get;
_set = set;
_key = key;
_selector = new KeyedItemSelector<TValue, TKey>(this, nameof(value), items, key);
}
public TValue value { get => _selector.value; set => _selector.value = value; }
public IObservableCollection<TValue> 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<T, TValue, TKey> : ViewModelBase, ITemplatedPropertyWrapperVM<T> where TKey : struct, IEquatable<TKey> {
readonly Func<T, IEnumerable<TKey>> _get;
readonly Action<T, IEnumerable<TKey>> _set;
readonly Func<TValue, TKey> _key;
readonly KeyedMultiSelector<TValue, TKey> _selector;
readonly string _template_key;
public MultiKeyedItemSelectorVM(string template_key, IObservableCollection<TValue> items, Func<T, IEnumerable<TKey>> get, Action<T, IEnumerable<TKey>> set, Func<TValue, TKey> key) {
_template_key = template_key;
_get = get;
_set = set;
_key = key;
_selector = new KeyedMultiSelector<TValue, TKey>(items, key);
}
public ObservableCollection<TValue> value => _selector.selected_items;
public IObservableCollection<TValue> 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));
}
}
}