diff --git a/src/client/Directory.Build.Targets b/src/client/Directory.Build.Targets index c23904d77..c0a3999b0 100644 --- a/src/client/Directory.Build.Targets +++ b/src/client/Directory.Build.Targets @@ -39,6 +39,7 @@ - 18 285 16 -16 15 @@ -293,7 +292,7 @@ - + - + @@ -321,7 +320,9 @@ - + + + /// Interaction logic for ExecutionStrategyEditor.xaml /// - partial class ExecutionStrategyEditor : Control { + partial class ExecutionStrategyEditor : Control { + public const string + RemovableColumnHeaderTemplateKey = "RemovableColumnHeaderTemplate", + NonRemovableColumnHeaderTemplateKey = "ReadOnlyColumnHeaderTemplate", + AddColumnPlaceholderKey = "AddColumnPlaceholder"; + public const double GroupLevelIndent = 18; + static ExecutionStrategyEditor() => DefaultStyleKeyProperty.OverrideMetadata(typeof(ExecutionStrategyEditor), new FrameworkPropertyMetadata(typeof(ExecutionStrategyEditor))); @@ -196,7 +202,7 @@ namespace mbts.ui.spark { if (dg != null) { var legs = LegTuples; dg.Columns.SetItems(legs.Select(_column_factory)); - if (IsNew) dg.Columns.Add((DataGridColumn)FindResource("AddColumnPlaceholder")); + if (IsNew) dg.Columns.Add((DataGridColumn)FindResource(AddColumnPlaceholderKey)); _dg_line_adorner = AdornerHelper.attach_continuously_on_loaded(() => new ExecutionStrategyGridLineAdorner(dg), dg); _legs_collection_changed_sub = (legs as INotifyCollectionChanged)?.Subscribe((s, e) => dg.Columns.ReflectChange(legs, _column_factory, e)); } @@ -204,7 +210,7 @@ namespace mbts.ui.spark { DataGridColumn _column_factory(LegSpreaderParamsTuple l) { var col = new DataGridColumnInternal(l.leg.Security, ParameterCellTemplateConverter, ParameterCellEditingTemplateConverter) { Width = 75, }; - if (IsNew) col.HeaderTemplate = (DataTemplate)FindResource("RemovableColumnHeaderTemplate"); + col.HeaderTemplate = (DataTemplate)FindResource(IsNew ? RemovableColumnHeaderTemplateKey : NonRemovableColumnHeaderTemplateKey); DataGridEx.SetRightBorder(col, new DataGridExVerticalLine(false, true, Colors.DarkGray, 1)); return col; } @@ -240,7 +246,7 @@ namespace mbts.ui.spark { FrameworkElement _generate_element(IValueConverter cell_template_converter) { var rv = new ContentControl(); rv.SetBinding(ContentControl.ContentProperty, new Binding()); - rv.SetBinding(ContentControl.ContentTemplateProperty, new Binding("data_type") { Converter = cell_template_converter }); + rv.SetBinding(ContentControl.ContentTemplateProperty, new Binding(nameof(ICell.data_type)) { Converter = cell_template_converter }); return rv; } } diff --git a/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs b/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs index c739aea82..62150b6b6 100644 --- a/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs +++ b/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs @@ -25,7 +25,10 @@ namespace mbts.ui.spark void _items_presenter_SizeChanged(object sender, SizeChangedEventArgs e) { InvalidateVisual(); } protected override void draw_vertical_line(DrawingContext dc, double x, DataGridExVerticalLine line) { - if (_items_presenter != null) dc.DrawLine(line.pen.Value, new Point(x - 10, 58), new Point(x - 10, _items_presenter.ActualHeight + 58)); + x -= GroupLevelIndent; + var start = _grid.TranslatePoint(new Point(x, _grid.super_header_height + _col_header_presenter.ActualHeight), this); + var stop = _grid.TranslatePoint(new Point(x, _grid.ActualHeight), this); + dc.DrawLine(line.pen.Value, start, stop); } } } diff --git a/src/client/spark/Orders/OrderModificationControl.xaml.cs b/src/client/spark/Orders/OrderModificationControl.xaml.cs index 0e6f61c46..067e32cf0 100644 --- a/src/client/spark/Orders/OrderModificationControl.xaml.cs +++ b/src/client/spark/Orders/OrderModificationControl.xaml.cs @@ -20,6 +20,10 @@ namespace mbts.ui.spark { public DataTemplate StopLimitOrderTemplate { get; set; } public DataTemplate StopMarketOrderTemplate { get; set; } public DataTemplate TimeBoxOrderTemplate { get; set; } + public DataTemplate TickOrderTemplate { get; set; } + public DataTemplate LeanOrderTemplate { get; set; } + public DataTemplate JoinOrderTemplate { get; set; } + public DataTemplate TopOrderTemplate { get; set; } public DataTemplate IcebergOrderTemplate { get; set; } public DataTemplate SpreaderTemplate { get; set; } public DataTemplate BTSStopOrderTemplate { get; set; } @@ -33,6 +37,10 @@ namespace mbts.ui.spark { case CustomOrderDefinition.CustomOneofCase.Stop: return StopMarketOrderTemplate; case CustomOrderDefinition.CustomOneofCase.StopLimit: return StopLimitOrderTemplate; case CustomOrderDefinition.CustomOneofCase.TimeBox: return TimeBoxOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Tick: return TickOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Lean: return LeanOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Join: return JoinOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Top: return TopOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate; } diff --git a/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs new file mode 100644 index 000000000..af9bde098 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs @@ -0,0 +1,287 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineJoinOrderProperties + { + public InlineJoinOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + + var hedgetype = CustomOneofCase.Lean; + if(!child_order_types.Contains(hedgetype)) + hedgetype = CustomOneofCase.Limit; + + //ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types"); + this.selected_hedge_order_type = new InlineUserProperty(hedgetype, true); + this.hedge_order_types = new InlineUserProperty>(child_order_types, true); + + tick_offset_on_deploy = new InlineUserProperty(0, false); + join_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); + enable_hedge = new InlineUserProperty(false, false); + hedge_ticks = new InlineUserProperty(1, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + public readonly InlineUserProperty selected_hedge_order_type; + public readonly InlineUserProperty> hedge_order_types; + + + public readonly InlineUserProperty tick_offset_on_deploy; + public readonly InlineUserProperty join_threshold; + + public readonly InlineUserProperty enable_hedge; + public readonly InlineUserProperty hedge_ticks; + + } + + class JoinOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineJoinOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + ObservableAutoWrapper _hedge_order_choices; + IOrderTypeVM _hedge_order; + IDisposable _hedge_order_errors_sub; + + public uint tick_offset_on_deploy { get; set; } = 0; + public bts.spark.QuantityMeasure join_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + bool _enable_hedge = false; + public bool enable_hedge + { + get { return _enable_hedge; } + set + { + _enable_hedge = value; + RaisePropertyChanged(nameof(enable_hedge)); + } + } + public int hedge_ticks { get; set; } = 1; + + public JoinOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineJoinOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public JoinOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (_hedge_order_choices != null && (_hedge_order == null || p.selected_hedge_order_type.force_override)) + { + _select_hedge_order(p.selected_hedge_order_type.value); + } + if (p.tick_offset_on_deploy.force_override) + { + tick_offset_on_deploy = p.tick_offset_on_deploy.value; + RaisePropertyChanged(nameof(tick_offset_on_deploy)); + } + if (p.join_threshold.force_override) + { + join_threshold = p.join_threshold.value; + RaisePropertyChanged(nameof(join_threshold)); + } + if (p.enable_hedge.force_override) + { + enable_hedge = p.enable_hedge.value; + RaisePropertyChanged(nameof(enable_hedge)); + } + if (p.hedge_ticks.force_override) + { + hedge_ticks = p.hedge_ticks.value; + RaisePropertyChanged(nameof(hedge_ticks)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + if (_hedge_order == null && enable_hedge) + _select_hedge_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.join_order(); + i.TickOffsetOnDeploy = tick_offset_on_deploy; + i.JoinThreshold = join_threshold; + i.EnableHedge = enable_hedge; + i.HedgeTicks = hedge_ticks; + child_order.assign_to(i.Child); + if(enable_hedge && hedge_order != null) + hedge_order.assign_to(i.Hedge); + value.Join = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public ICollection hedge_order_types + { + get + { + if (_hedge_order_choices == null) + _hedge_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _hedge_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public IOrderTypeVM hedge_order + { + get + { + init(); + return _hedge_order; + } + set + { + Disposable.dispose(ref _hedge_order_errors_sub); + _hedge_order = value; + _hedge_order?.init(); + if (_hedge_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _hedge_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(hedge_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + if (_hedge_order_choices != null) + _hedge_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + if (_hedge_order == null && _security.HasValue && enable_hedge) + _select_hedge_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _select_hedge_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_hedge_order_type.has_value ? + _inline_props.selected_hedge_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_hedge_order(ot); + } + + void _select_hedge_order(CustomOneofCase ot) + { + _hedge_order = hedge_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_hedge_order == null) + _hedge_order = hedge_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(hedge_order)); + } + + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + + if ( (_hedge_order == null && enable_hedge) || (_hedge_order is INotifyDataErrorInfo hdei && hdei.HasErrors)) + set_error(nameof(hedge_order), string.Empty, true); + else clear_error(nameof(hedge_order)); + + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs new file mode 100644 index 000000000..ae63ec031 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs @@ -0,0 +1,174 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineLeanOrderProperties + { + public InlineLeanOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + cross_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); + max_chase_ticks = new InlineUserProperty(10, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + + public readonly InlineUserProperty cross_threshold; + public readonly InlineUserProperty max_chase_ticks; + } + + class LeanOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineLeanOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + public uint max_chase_ticks { get; set; } = 10; + + public LeanOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineLeanOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public LeanOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (p.cross_threshold.force_override) + { + cross_threshold = p.cross_threshold.value; + RaisePropertyChanged(nameof(cross_threshold)); + } + if (p.max_chase_ticks.force_override) + { + max_chase_ticks = p.max_chase_ticks.value; + RaisePropertyChanged(nameof(max_chase_ticks)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.lean_order(); + i.CrossThreshold = cross_threshold; + i.MaxChaseTicks = max_chase_ticks; + child_order.assign_to(i.Child); + value.Lean = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index 3e780a072..b9467cc56 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -14,6 +14,10 @@ namespace mbts.spark { public static IOrderTypeVM stop(OrdersModel model) => new StopOrderVM(model); public static IOrderTypeVM stop_limit(OrdersModel model) => new StopLimitOrderVM(model); public static IOrderTypeVM time_box(OrdersModel model, IObservable security_source) => new TimeBoxOrderVM(model, security_source); + public static IOrderTypeVM tick(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); + public static IOrderTypeVM lean(OrdersModel model, IObservable security_source) => new LeanOrderVM(model, security_source); + public static IOrderTypeVM join(OrdersModel model, IObservable security_source) => new JoinOrderVM(model, security_source); + public static IOrderTypeVM top(OrdersModel model, IObservable security_source) => new TopOrderVM(model, security_source); public static IOrderTypeVM iceberg(OrdersModel model, IObservable security_source) => new IcebergOrderVM(model, security_source); public static IOrderTypeVM spreader(OrdersModel model, IObservable security_source) => new SpreaderOrderVM(model, security_source); @@ -27,6 +31,10 @@ namespace mbts.spark { case CustomOneofCase.Stop: return stop(model); case CustomOneofCase.StopLimit: return stop_limit(model); case CustomOneofCase.TimeBox: return time_box(model, security_source); + case CustomOneofCase.Tick: return tick(model, security_source); + case CustomOneofCase.Lean: return lean(model, security_source); + case CustomOneofCase.Join: return join(model, security_source); + case CustomOneofCase.Top: return top(model, security_source); case CustomOneofCase.Iceberg: return iceberg(model, security_source); case CustomOneofCase.Spreader: return spreader(model, security_source); default: throw new NotImplementedException(); diff --git a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs index 86392c39e..2ae4de187 100644 --- a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs @@ -1,15 +1,17 @@ using bts.api; using bts.api.orderman; using mbts.ui; +using mbts.ui.controls; using System; +using System.Collections.Generic; using System.Reactive.Linq; namespace mbts.spark { static partial class OrderTypeVMFactory { private class SpreaderOrderVM : OrderTypeVMBase, IOrderTypeVM, IDisposable { readonly Property _template; + readonly StrategyEditorWrapper _strategy_editor_wrapper; IDisposable _dispose; - SyntheticEditorVM _strategy_editor; public SpreaderOrderVM(OrdersModel model, IObservable security_source) : this(model, security_source, security_source.SelectMany(s => model.spreader.security_strategy(s.Id) @@ -26,15 +28,15 @@ namespace mbts.spark { IObservable> order_template_source) : base(model) { _template = backing(nameof(template), new SpreaderOrderDefinitionImmutable?()); + _strategy_editor_wrapper = new StrategyEditorWrapper(this); _dispose = Disposable.Create( + _strategy_editor_wrapper, _template.ObserveOnDispatcher().Subscribe(vals => { _validate(); }), order_template_source.ObserveOnDispatcher().Subscribe(prop => { if (prop.force_override || (!template.HasValue && prop.has_value)) { _template.Value = prop.value; - if (_strategy_editor != null) - _strategy_editor.set_synthetic(prop.value.Security, prop.value.ExecutionStrategy); _validate(); } }) @@ -43,23 +45,14 @@ namespace mbts.spark { } public SpreaderOrderDefinitionImmutable? template => _template.Value; - - public SyntheticEditorVM strategy_editor { - get { - if (_strategy_editor == null && template.HasValue) { - var def = template.Value; - _strategy_editor = new SyntheticEditorVM(model.spreader, def.Security, def.ExecutionStrategy, model.security_has_working_orders(def.Security.Id)); - } - return _strategy_editor; - } - } - + public SyntheticEditorVM strategy_editor => _strategy_editor_wrapper.vm; + public IEnumerable skirt_items => _strategy_editor_wrapper.skirt_items; public override bool editable_properties_open { get => base.editable_properties_open; set { - if (!value && template.HasValue && _strategy_editor != null) { + if (!value && template.HasValue && strategy_editor != null) { var mutable_template = template.Value.CloneToMutable(); - mutable_template.ExecutionStrategy = _strategy_editor.get_strategy().CloneToMutable(); + mutable_template.ExecutionStrategy = _strategy_editor_wrapper.vm.get_strategy().CloneToMutable(); _template.Value = new SpreaderOrderDefinitionImmutable(mutable_template); } base.editable_properties_open = value; @@ -80,6 +73,39 @@ namespace mbts.spark { set_error(nameof(template), "Waiting for security and/or strategy.", true); else clear_error(nameof(template)); } + + // lazily initializes SyntheticEditorVM and associated dialog skirt items + class StrategyEditorWrapper : IDisposable { + readonly SpreaderOrderVM _owner; + SyntheticEditorVM _vm; + DialogSkirtItem _save_strategy_item; + + public StrategyEditorWrapper(SpreaderOrderVM owner) { + _owner = owner; + _owner._template.Changed += _order_template_changed; + } + + public SyntheticEditorVM vm { get { _init(); return _vm; } } + public IEnumerable skirt_items { get { _init(); yield return _save_strategy_item; } } + + public void Dispose() { + Disposable.dispose(ref _vm); + _owner._template.Changed -= _order_template_changed; + } + + void _init() { + if (_vm == null && _owner.template.HasValue) { + var def = _owner.template.Value; + _vm = new SyntheticEditorVM(_owner.model.spreader, def.Security, def.ExecutionStrategy, _owner.model.security_has_working_orders(def.Security.Id)); + _save_strategy_item = new DialogSkirtItem("Save Strategy", _vm.commit); + } + } + + void _order_template_changed(SpreaderOrderDefinitionImmutable? oldval, SpreaderOrderDefinitionImmutable? newval) { + if (_vm != null && newval.HasValue) + _vm.set_synthetic(newval.Value.Security, newval.Value.ExecutionStrategy); + } + } } } } \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs new file mode 100644 index 000000000..afde6e6ca --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs @@ -0,0 +1,201 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineTickOrderProperties + { + public InlineTickOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + tick_offset_on_deploy = new InlineUserProperty(0, false); + cross_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); + cross_ticks = new InlineUserProperty(0, false); + max_chase_ticks = new InlineUserProperty(10, false); + detach_on_toward = new InlineUserProperty(true, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + + public readonly InlineUserProperty tick_offset_on_deploy; + public readonly InlineUserProperty cross_threshold; + public readonly InlineUserProperty cross_ticks; + public readonly InlineUserProperty max_chase_ticks; + public readonly InlineUserProperty detach_on_toward; + } + + class TickOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineTickOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + public uint tick_offset_on_deploy { get; set; } = 0; + public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + public uint cross_ticks { get; set; } = 0; + public uint max_chase_ticks { get; set; } = 10; + public bool detach_on_toward { get; set; } = true; + + public TickOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineTickOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public TickOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (p.tick_offset_on_deploy.force_override) + { + tick_offset_on_deploy = p.tick_offset_on_deploy.value; + RaisePropertyChanged(nameof(tick_offset_on_deploy)); + } + if (p.cross_threshold.force_override) + { + cross_threshold = p.cross_threshold.value; + RaisePropertyChanged(nameof(cross_threshold)); + } + if (p.cross_ticks.force_override) + { + cross_ticks = p.cross_ticks.value; + RaisePropertyChanged(nameof(cross_ticks)); + } + if (p.max_chase_ticks.force_override) + { + max_chase_ticks = p.max_chase_ticks.value; + RaisePropertyChanged(nameof(max_chase_ticks)); + } + if (p.detach_on_toward.force_override) + { + detach_on_toward = p.detach_on_toward.value; + RaisePropertyChanged(nameof(detach_on_toward)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.tick_order(); + i.TickOffsetOnDeploy = tick_offset_on_deploy; + i.CrossThreshold = cross_threshold; + i.CrossTicks = cross_ticks; + i.MaxChaseTicks = max_chase_ticks; + i.DetachOnToward = detach_on_toward; + child_order.assign_to(i.Child); + value.Tick = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs new file mode 100644 index 000000000..d96b255cd --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs @@ -0,0 +1,287 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineTopOrderProperties + { + public InlineTopOrderProperties(CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + + var hedgetype = CustomOneofCase.Lean; + if(!child_order_types.Contains(hedgetype)) + hedgetype = CustomOneofCase.Limit; + this.selected_hedge_order_type = new InlineUserProperty(hedgetype, true); + this.hedge_order_types = new InlineUserProperty>(child_order_types, true); + + watch_level_tick_offset = new InlineUserProperty(0, false); + top_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }, false); + enable_hedge = new InlineUserProperty(false, false); + hedge_ticks = new InlineUserProperty(1, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + public readonly InlineUserProperty selected_hedge_order_type; + public readonly InlineUserProperty> hedge_order_types; + + + public readonly InlineUserProperty watch_level_tick_offset; + public readonly InlineUserProperty top_threshold; + + public readonly InlineUserProperty enable_hedge; + public readonly InlineUserProperty hedge_ticks; + + } + + class TopOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineTopOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + ObservableAutoWrapper _hedge_order_choices; + IOrderTypeVM _hedge_order; + IDisposable _hedge_order_errors_sub; + + public uint watch_level_tick_offset { get; set; } = 0; + public bts.spark.QuantityMeasure top_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + bool _enable_hedge = false; + public bool enable_hedge + { + get { return _enable_hedge; } + set + { + _enable_hedge = value; + RaisePropertyChanged(nameof(enable_hedge)); + } + } + public int hedge_ticks { get; set; } = 1; + + public TopOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineTopOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) + { } + + public TopOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => + { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (_hedge_order_choices != null && (_hedge_order == null || p.selected_hedge_order_type.force_override)) + { + _select_hedge_order(p.selected_hedge_order_type.value); + } + if (p.watch_level_tick_offset.force_override) + { + watch_level_tick_offset = p.watch_level_tick_offset.value; + RaisePropertyChanged(nameof(watch_level_tick_offset)); + } + if (p.top_threshold.force_override) + { + top_threshold = p.top_threshold.value; + RaisePropertyChanged(nameof(top_threshold)); + } + if (p.enable_hedge.force_override) + { + enable_hedge = p.enable_hedge.value; + RaisePropertyChanged(nameof(enable_hedge)); + } + if (p.hedge_ticks.force_override) + { + hedge_ticks = p.hedge_ticks.value; + RaisePropertyChanged(nameof(hedge_ticks)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + if (_hedge_order == null && enable_hedge) + _select_hedge_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.top_order(); + i.WatchLevelTickOffset = watch_level_tick_offset; + i.TopThreshold = top_threshold; + i.EnableHedge = enable_hedge; + i.HedgeTicks = hedge_ticks; + child_order.assign_to(i.Child); + if (enable_hedge && hedge_order != null) + hedge_order.assign_to(i.Hedge); + value.Top = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public ICollection hedge_order_types + { + get + { + if (_hedge_order_choices == null) + _hedge_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _hedge_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public IOrderTypeVM hedge_order + { + get + { + init(); + return _hedge_order; + } + set + { + Disposable.dispose(ref _hedge_order_errors_sub); + _hedge_order = value; + _hedge_order?.init(); + if (_hedge_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _hedge_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(hedge_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + if (_hedge_order_choices != null) + _hedge_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + if (_hedge_order == null && _security.HasValue && enable_hedge) + _select_hedge_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _select_hedge_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_hedge_order_type.has_value ? + _inline_props.selected_hedge_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_hedge_order(ot); + } + + void _select_hedge_order(CustomOneofCase ot) + { + _hedge_order = hedge_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_hedge_order == null) + _hedge_order = hedge_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(hedge_order)); + } + + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + + if ((_hedge_order == null && enable_hedge) || (_hedge_order is INotifyDataErrorInfo hdei && hdei.HasErrors)) + set_error(nameof(hedge_order), string.Empty, true); + else clear_error(nameof(hedge_order)); + + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Spark.csproj b/src/client/spark/Spark.csproj index f5d68f735..c549c2d95 100644 --- a/src/client/spark/Spark.csproj +++ b/src/client/spark/Spark.csproj @@ -15,7 +15,7 @@ WinExe mbts.ui.shell.App bts - 7.1 + 7.2 true 1.0.0 diff --git a/src/client/spark/core/FontsAndColors/BTSColors.cs b/src/client/spark/core/FontsAndColors/BTSColors.cs index 943a2b1f5..407deaca3 100644 --- a/src/client/spark/core/FontsAndColors/BTSColors.cs +++ b/src/client/spark/core/FontsAndColors/BTSColors.cs @@ -199,10 +199,10 @@ namespace mbts.ui { public static BTSColor straddle_theovsmarket_positive { get { return BTSCoreColors.green_light; } } // Order Types - public static BTSColor tick_order { get { return new BTSColor(31, 4, 57);}} - public static BTSColor lean_order { get { return new BTSColor(110, 77, 143);}} - public static BTSColor join_order { get { return new BTSColor(15, 1, 29);}} - public static BTSColor leader_order { get { return new BTSColor(40, 9, 72);}} + public static BTSColor tick_order { get { return BTSColors.purple.rgb_color();}} + public static BTSColor lean_order { get { return BTSColors.purple.rgb_color();}} + public static BTSColor join_order { get { return BTSColors.purple.rgb_color();}} + public static BTSColor top_order { get { return BTSColors.purple.rgb_color();}} } public static class AW2 { diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index 1d42ae646..fe7082c06 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -10,6 +10,7 @@ +