diff --git a/src/client/spark/core/Utility/ViewModelBase.cs b/src/client/spark/core/Utility/ViewModelBase.cs index 8fa702aaf..59fee1bfa 100644 --- a/src/client/spark/core/Utility/ViewModelBase.cs +++ b/src/client/spark/core/Utility/ViewModelBase.cs @@ -23,6 +23,11 @@ namespace mbts.ui.shell { void clear_error(string property); } + interface IReadOnlyProperty { + event PropertyChange Changing, Changed; + T value { get; } + } + interface IProperty : IObservable<(T oldval, T newval)> { event PropertyChange Changing, Changed; T Value { get; set; } @@ -41,6 +46,20 @@ namespace mbts.ui.shell { else vm.set_error(property, message); } + public static IDisposable subscribe_changed(this IProperty property, IObserver<(T oldval, T newval)> observer) { + property.Changed += on_changed; + return Disposable.Create(() => property.Changed -= on_changed); + void on_changed(T oldval, T newval) => + observer.OnNext((oldval, newval)); + } + + public static IDisposable subscribe_changing(this IProperty property, IObserver<(T oldval, T newval)> observer) { + property.Changing += on_changing; + return Disposable.Create(() => property.Changing -= on_changing); + void on_changing(T oldval, T newval) => + observer.OnNext((oldval, newval)); + } + public static IObservable subscribe_has_errors(this INotifyDataErrorInfo vm) => Observable.Create(o => { vm.ErrorsChanged += on_errors_changed; @@ -53,6 +72,8 @@ namespace mbts.ui.shell { // ensure notifications will be in on the same thread as IProperty.Subscribe (don't use .Select extension) Observable.Create(o => property.Subscribe(ch => o.OnNext(ch.newval))); + //public static IDisposable S + public static IProperty block_reentrancy(this IProperty source) => new GatedPropertyWrapper(source); @@ -89,6 +110,7 @@ namespace mbts.ui.shell { return GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); }); } + protected void RaisePropertyChanged([CallerMemberName]string property="") { if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs(property)); diff --git a/src/client/spark/view/ViewModels/BooleanParameterVM.cs b/src/client/spark/view/ViewModels/BooleanParameterVM.cs new file mode 100644 index 000000000..cce9030cb --- /dev/null +++ b/src/client/spark/view/ViewModels/BooleanParameterVM.cs @@ -0,0 +1,11 @@ +namespace mbts.ui.viewmodels { + class BooleanParameterVM : ParameterVM { + public BooleanParameterVM(string name) + : base(name) { } + } + + class BooleanOverrideParameterVM : ParameterOverrideVM { + public BooleanOverrideParameterVM(string name) + : base(name) { } + } +} \ No newline at end of file diff --git a/src/client/spark/view/ViewModels/ColorParameterVM.cs b/src/client/spark/view/ViewModels/ColorParameterVM.cs new file mode 100644 index 000000000..8c433cb40 --- /dev/null +++ b/src/client/spark/view/ViewModels/ColorParameterVM.cs @@ -0,0 +1,29 @@ +using mbts.ui.controls.color_picker; +using System.Collections.ObjectModel; +using System.Linq; +using System.Windows.Media; + +namespace mbts.ui.viewmodels { + class ColorParameterVM : ParameterVM { + ObservableCollection _palettes; + + public ColorParameterVM(string name) + : base(name) => + value = Colors.Black; + + public ObservableCollection palettes => _palettes ?? + (_palettes = new ObservableCollection( + ColorPalette.all_presets() + .Select(p => new ColorPaletteVM(p)))); + } + + class ColorOverrideParameterVM : ParameterOverrideVM { + ObservableCollection _palettes; + + public ColorOverrideParameterVM(string name) + : base(name) { } + + public ObservableCollection palettes => + _palettes ?? (_palettes = new ObservableCollection(ColorPalette.all_presets().Select(p => new ColorPaletteVM(p)))); + } +} \ No newline at end of file diff --git a/src/client/spark/view/ViewModels/DoubleParameterVM.cs b/src/client/spark/view/ViewModels/DoubleParameterVM.cs new file mode 100644 index 000000000..a956112cb --- /dev/null +++ b/src/client/spark/view/ViewModels/DoubleParameterVM.cs @@ -0,0 +1,6 @@ +namespace mbts.ui.viewmodels { + class DoubleParameterVM : ParameterVM { + public DoubleParameterVM(string name) + : base(name) { } + } +} \ No newline at end of file diff --git a/src/client/spark/view/ViewModels/FontParameterVM.cs b/src/client/spark/view/ViewModels/FontParameterVM.cs new file mode 100644 index 000000000..bb62da598 --- /dev/null +++ b/src/client/spark/view/ViewModels/FontParameterVM.cs @@ -0,0 +1,60 @@ +using mbts.ui.shell; +using mbts.ui.utility.text; +using System.Collections; +using System.Windows; +using System.Windows.Media; + +namespace mbts.ui.viewmodels { + class FontOverrideParameterVM { + public FontOverrideParameterVM(string name = "Font") { + this.name = name; + family = new ParameterOverrideVM($"{name} Family"); + weight = new ParameterOverrideVM($"{name} Weight"); + size = new ParameterOverrideVM($"{name} Size"); + } + + public string name { get; } + + public ParameterOverrideVM family { get; } + public ParameterOverrideVM weight { get; } + public ParameterOverrideVM size { get; } + + public IEnumerable parameters { + get { + yield return family; + yield return weight; + yield return size; + } + } + } + + class FontParameterVM : ParameterVM<(FontFamily family, FontWeight weight, double size)> { + FontFamily _family; + FontWeight _weight; + double _size; + + public FontParameterVM(string name) : base(name) { + add_dependency(nameof(family), v => v.family, f => family = f, (tup, fam) => (fam, tup.weight, tup.size)); + add_dependency(nameof(weight), v => v.weight, w => weight = w, (tup, weight) => (tup.family, weight, tup.size)); + add_dependency(nameof(size), v => v.size, s => size = s, (tup, size) => (tup.family, tup.weight, size)); + } + + public FontFamily family { get => _family; set => Set(ref _family, value); } + public FontWeight weight { get => _weight; set => Set(ref _weight , value); } + public double size { get => _size; set => Set(ref _size, value); } + } + + class FontWeightOverrideParameterVM : ParameterOverrideVM { + FontFamily _family = TextUtils.StandardFontFamily; + double _size = FontSizes.Regular; + + public FontWeightOverrideParameterVM(string name = "Font Weight") + : base(name) { } + // the font family/size props serve a couple purposes, if the weight param is 1 part of a larger typeface parameter + // 1) the view may display the font weight items with the relevant font family/size, + // to provide a preview to the user of what the overall typeface would look like with each font weight. + // 2) the view may filter out font weights that are not supported by the relevant font family (e.g., 'Arial Bold' does not support the 'Bold' font weight, bc it is already bold) + public FontFamily family { get => _family; set => Set(ref _family, value); } + public double size { get => _size; set => Set(ref _size, value); } + } +} \ No newline at end of file diff --git a/src/client/spark/view/ViewModels/ParameterVM.cs b/src/client/spark/view/ViewModels/ParameterVM.cs new file mode 100644 index 000000000..efaa61f7e --- /dev/null +++ b/src/client/spark/view/ViewModels/ParameterVM.cs @@ -0,0 +1,325 @@ +using bts.utils; +using mbts.ui.shell; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Reactive; +using System.Reactive.Linq; + +namespace mbts.ui.viewmodels { + // as parameters are frequently grouped together, + // a non-generic 'result_changed' delegate is useful for responding to changes from any PropertyVM. + interface IResultChanged { + event Action result_changed; + } + + interface IReadOnlyParameterVM : IReadOnlyProperty { } + interface IParameterVM : IReadOnlyParameterVM { + new T value { get; set; } + } + + class PropertyVM : ViewModelBase, IProperty, IResultChanged, INotifyPropertyChanged, IRaiseNotifyPropertyChanged { + readonly IEqualityComparer _comparer; + T _value; + + public PropertyVM() + : this(EqualityComparer.Default) { } + + public PropertyVM(IEqualityComparer comparer) => + _comparer = comparer; + + public event PropertyChange Changing; + public event PropertyChange Changed; + public event Action result_changed; + + public virtual T value { + get => _value; + set { + if (!_comparer.Equals(_value, value)) { + // changing + on_changing_begin(_value, value); + Changing?.Invoke(_value, value); + on_changing_end(_value, value); + var oldval = _value; + _value = value; + // changed + on_changed_begin(oldval, value); + Changed?.Invoke(oldval, _value); + result_changed?.Invoke(); + on_changed_end(oldval, value); + RaisePropertyChanged(); + } + } + } + + T IProperty.Value { + get => value; + set => this.value = value; + } + + public IDisposable Subscribe(IObserver<(T oldval, T newval)> observer) => + this.subscribe_changed(observer); + + protected virtual void on_changing_begin(T oldval, T newval) { } + protected virtual void on_changing_end(T oldval, T newval) { } + protected virtual void on_changed_begin(T oldval, T newval) { } + protected virtual void on_changed_end(T oldval, T newval) { } + } + + class ParameterVM : PropertyVM, IParameterVM, IResultChanged { + string _name; + PropertyChangedDemuxer _demuxer_backing; + PropertyChangedDemuxer _demuxer => + _demuxer_backing ?? (_demuxer_backing = new PropertyChangedDemuxer(this)); + + public ParameterVM() { } + + public ParameterVM(string name) + : this(name, EqualityComparer.Default) { } + + public ParameterVM(string name, IEqualityComparer comparer) + : base(comparer) { + _name = name; + } + + public string name { + get => _name; + set { + if (_name != value) { + _name = value; + RaisePropertyChanged(); + } + } + } + + protected IDisposable add_dependency(string prop_name, Func src_getter, Action vm_setter, Func update) { + // + bool is_busy = false; + Changed += on_changed; + _demuxer.subscribe(prop_name).Subscribe(on_vm_changed); + return Disposable.Create(() => Changed -= on_changed); + void on_changed(T oldval, T newval) { + if (is_busy) + return; + is_busy = true; + var v = src_getter(newval); + vm_setter(v); + is_busy = false; + } + void on_vm_changed(TValue v) { + if (is_busy) + return; + is_busy = true; + value = update(value, v); + is_busy = false; + } + } + + public class Dependency { + readonly Func _get; + readonly Func _set; + readonly Action _assign; + readonly ParameterVM _owner; + + public Dependency( + Func get, + Func set, + Action assign, + ParameterVM owner) { + _get = get; + _set = set; + _assign = assign; + _owner = owner; + } + + public void on_source(T src) => + _assign(_get(src)); + + public void on_value(TValue value) => + _owner.value = _set(_owner.value, value); + } + } + + class ParameterOverrideVM : ViewModelBase { + static readonly IPropertyChangedDetector> _update = + ObjectSnapshot.build_detector_except>(nameof(name), nameof(is_expanded)); + + readonly IEqualityComparer _comparer; + + bool + _can_override, + _is_overridden, + _is_expanded; + T _override_value, _default_value; + + public ParameterOverrideVM(string name) + : this(name, EqualityComparer.Default) { } + + public ParameterOverrideVM(string name, IEqualityComparer comparer) { + this.name = name; + _comparer = comparer; + } + + public string name { get; } + + public bool is_expanded { + get => _is_expanded; + set => Set(ref _is_expanded, value); + } + + public bool can_override { + get => _can_override; + set { + using (detect_property_changes()) + _can_override = value; + } + } + + /// indicates whether both and are true. + public bool effective_is_overridden => + can_override && is_overridden; + + public T effective_value => + effective_is_overridden ? override_value : default_value; + + /// is orthogonal to + public bool is_overridden { + get => _is_overridden; + set { + using (_update.detect_changes(this)) + _is_overridden = value; + } + } + public virtual T default_value { + get => _default_value; + set { + using (_update.detect_changes(this)) + _default_value = value; + } + } + public virtual T override_value { + get => _override_value; + set { + if (!_comparer.Equals(value, _override_value)) { + using (_update.detect_changes(this)) { + is_overridden = true; + _override_value = value; + } + } + } + } + + // unlike the override_value setter, this method does not set is_override to true. + public void set_override(T value) { + using (_update.detect_changes(this)) + _override_value = value; + } + + public override string ToString() => + effective_is_overridden ? $"{override_value} ({default_value})" : default_value?.ToString(); + } + + class ParameterGroupVM : ViewModelBase, IResultChanged { + bool _is_expanded; + IDisposable _parameters_changed_hook; + + public ParameterGroupVM(string name) + : this(name, null) { } + + public ParameterGroupVM(string name, ObservableCollection parameters) { + this.name = name; + this.parameters = parameters ?? new ObservableCollection(); + } + + public event Action result_changed { + add { + _result_changed += value; + if (_parameters_changed_hook == null) { + _parameters_changed_hook = ObservableAutoWrapper.connect_item_hooks(parameters, + obj => { + if (obj is IResultChanged rc) { + rc.result_changed += _raise_result_changed; + return Disposable.Create(() => rc.result_changed -= _raise_result_changed); + } + return Disposable.empty; + }); + } + } + remove { + _result_changed -= value; + if (_result_changed == null) + Disposable.dispose(ref _parameters_changed_hook); + } + } + + event Action _result_changed; + + public string name { get; } + public ObservableCollection parameters { get; } + public bool is_expanded { get => _is_expanded; set => Set(ref _is_expanded, value); } + + public static ParameterGroupVM create(string name, params object[] parameters) => + new ParameterGroupVM(name, new ObservableCollection(parameters)); + + void _raise_result_changed() => + _result_changed?.Invoke(); + } + + class TabularParameterGroupVM : ParameterGroupVM { + object _selected_item; + + public TabularParameterGroupVM(string name) + : base(name) { } + + public TabularParameterGroupVM(string name, ObservableCollection parameters) + : base(name, parameters) { } + + public object selected_item { get => _selected_item; set => Set(ref _selected_item, value); } + + public new static TabularParameterGroupVM create(string name, params object[] parameters) => + new TabularParameterGroupVM(name, new ObservableCollection(parameters)); + } + + class HeaderedParameterGroupVM : ParameterGroupVM { + public HeaderedParameterGroupVM(string name) + : base(name) { } + + public HeaderedParameterGroupVM(string name, ObservableCollection parameters) + : base(name, parameters) { } + + public new static HeaderedParameterGroupVM create(string name, params object[] parameters) => + new HeaderedParameterGroupVM(name, new ObservableCollection(parameters)); + } + + static class ParameterVMExtensions { + public static IObservable Observe(this ParameterGroupVM parameter_group_vm) { + return Observable.Create(o => { + var notify_throttle = new DeferrableActionWrapper(notify_impl); + parameter_group_vm.PropertyChanged += on_prop_changed; + return Disposable.Create(ObservableAutoWrapper.connect_item_hooks(parameter_group_vm.parameters, obj => { + var hook = new System.Reactive.Disposables.CompositeDisposable(); + if (obj is IResultChanged rop) { + rop.result_changed += notify; + hook.Add(Disposable.Create(() => rop.result_changed -= notify)); + } else if (obj is INotifyPropertyChanged npc) { + npc.PropertyChanged += on_prop_changed; + hook.Add(Disposable.Create(() => npc.PropertyChanged -= on_prop_changed)); + } + return hook; + }), + Disposable.Create(() => parameter_group_vm.PropertyChanged -= on_prop_changed)); + void notify() { + using (notify_throttle.defer_execution()) + notify_throttle.execute(); + } + void notify_impl() => + o.OnNext(Unit.Default); + void on_prop_changed(object sender, PropertyChangedEventArgs e) => + notify(); + }); + } + } +} \ No newline at end of file diff --git a/src/client/spark/view/ViewModels/SelectorParameterVM.cs b/src/client/spark/view/ViewModels/SelectorParameterVM.cs new file mode 100644 index 000000000..ba52f30aa --- /dev/null +++ b/src/client/spark/view/ViewModels/SelectorParameterVM.cs @@ -0,0 +1,12 @@ +using mbts.ui.utility; +using System.Collections.Generic; +using System.Windows; + +namespace mbts.ui.viewmodels { + class HorizontalAlignmentParameterVM : ParameterVM { + public HorizontalAlignmentParameterVM(string name) + : base(name) { } + + public IReadOnlyList items => EnumHelper.get_values(); + } +} \ No newline at end of file diff --git a/src/client/spark/view/ViewModels/StringParameterVM.cs b/src/client/spark/view/ViewModels/StringParameterVM.cs new file mode 100644 index 000000000..d6bc98114 --- /dev/null +++ b/src/client/spark/view/ViewModels/StringParameterVM.cs @@ -0,0 +1,11 @@ +namespace mbts.ui.viewmodels { + class StringParameterVM : ParameterVM { + public StringParameterVM(string name) + : base(name) { } + } + + class StringOverrideParameterVM : ParameterOverrideVM { + public StringOverrideParameterVM(string name) + : base(name) { } + } +} \ No newline at end of file