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 @@
+