1143 lines
62 KiB
C#
1143 lines
62 KiB
C#
using bts;
|
|
using bts.api;
|
|
using bts.api.core;
|
|
using bts.api.orderman;
|
|
using bts.collections;
|
|
using bts.shell;
|
|
using bts.shell.fills;
|
|
using bts.shell.orderbook;
|
|
using bts.spark;
|
|
using bts.utils;
|
|
using mbts.persist;
|
|
using mbts.spark.utilities;
|
|
using mbts.ui;
|
|
using mbts.ui.controls;
|
|
using mbts.ui.settings;
|
|
using mbts.ui.shell;
|
|
using mbts.ui.spark;
|
|
using mbts.ui.utility;
|
|
using mbts.utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Specialized;
|
|
using System.Linq;
|
|
using System.Reactive.Disposables;
|
|
using System.Reactive.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using Columns = mbts.spark.OrderBookGridView.ColumnKeys;
|
|
|
|
namespace mbts.spark {
|
|
partial class OrderBookVM : DisposableViewModelBase, IHandleRowSelection, IHandleGridSorting {
|
|
const double
|
|
_min_right_panel_width = 200,
|
|
_min_order_params_height = 300,
|
|
_min_ladder_height = 100,
|
|
_min_fills_height = 100;
|
|
readonly IBus _bus;
|
|
readonly OrdersModel _model;
|
|
readonly Property<OrderBookRowVM> _current_row;
|
|
readonly DelegateProperty<bool> _show_order_params, _show_ladder, _show_fills, _can_attach_selected_orders, _can_detach_selected_orders;
|
|
readonly OperableHierarchicalCollection<OrderBookRowVM, OrderSecurity, uint> _row_collection;
|
|
readonly OrderBookColumnCollection _columns;
|
|
readonly IWindowSettingsManager<OrderBookGridSettings> _settings_manager;
|
|
readonly IWindowSettingsManager<GridSettings> _fills_settings_manager = new WindowSettingsManager<GridSettings>.DisconnectedImpl(FillsSettings.MiniGridSettings, FillsSettings.MiniGridSettings);
|
|
readonly SelectedOrderParamsMon _selected_params_mon;
|
|
readonly RightPanelModel _right_panel = new RightPanelModel();
|
|
OrderBookFillsGridSettings _cached_fills_settings = OrderBookStartupData.DefaultFillsGrid;
|
|
double
|
|
_raw_right_panel_width = OrderBookStartupData.Default.right_panel_width,
|
|
_order_params_height = OrderBookStartupData.Default.order_params_height,
|
|
_ladder_height = OrderBookStartupData.Default.ladder_height,
|
|
_fills_height = OrderBookStartupData.Default.fills_height;
|
|
bool
|
|
_show_right_panel = OrderBookStartupData.Default.show_right_panel,
|
|
_is_attaching_orders,
|
|
_is_row_collection_populated;
|
|
IReadOnlyDictionary<uint, OrderSecurity> _cached_orders = DictionaryHelper.empty<uint, OrderSecurity>();
|
|
IReadOnlyDictionary<uint, bool> _cached_attachable = DictionaryHelper.empty<uint, bool>(), _cached_detachable = DictionaryHelper.empty<uint, bool>();
|
|
HashSet<uint>
|
|
_attachable_selected_orders = new HashSet<uint>(),
|
|
_detachable_selected_orders = new HashSet<uint>();
|
|
FilterData _cached_filter_data;
|
|
|
|
public OrderBookVM(
|
|
IObservable<string> owner_title,
|
|
IBus bus,
|
|
INotificationService notification_service,
|
|
OrdersModel model,
|
|
IWindowSettingsManager<OrderBookGridSettings> settings_manager,
|
|
bool rows_are_initially_expanded = false) {
|
|
|
|
_bus = bus;
|
|
_model = model;
|
|
_selected_params_mon = new SelectedOrderParamsMon(model.dynamic_helper);
|
|
order_mod_vm = new OrderParamsVM(this, AlgoDefinitionVM.create(model, OrderDataHelper.Defaults.AlgoData(), editing_permissions: AlgoEditingPermissions.AllowEditValues));
|
|
order_mod_vm.algo_vm.editing_permissions_mask = AlgoEditingPermissions.None;
|
|
order_mod_vm.algo_vm.algo_root = null;
|
|
_show_order_params = backing(nameof(show_order_params), () => (_right_panel.visible_components & OrderBookRightPanelSettings.Components.Params) != 0);
|
|
_show_ladder = backing(nameof(show_ladder), () => (_right_panel.visible_components & OrderBookRightPanelSettings.Components.Ladder) != 0);
|
|
_show_fills = backing(nameof(show_fills), () => (_right_panel.visible_components & OrderBookRightPanelSettings.Components.Fills) != 0);
|
|
_right_panel.visible_changed += vis_comps => {
|
|
_show_order_params.refresh();
|
|
_show_ladder.refresh();
|
|
_show_fills.refresh();
|
|
};
|
|
_can_attach_selected_orders = backing(nameof(can_attach_selected_orders), () => _attachable_selected_orders.Count == selected_rows.Count && selected_rows.Count > 0);
|
|
_can_detach_selected_orders = backing(nameof(can_detach_selected_orders), () => _detachable_selected_orders.Count == selected_rows.Count && selected_rows.Count > 0);
|
|
attach_vm = new OrderParamsVM(this,
|
|
AlgoDefinitionVM.create(_model,
|
|
OrderDataHelper.Defaults.AlgoData(CustomOrderDefinition.CustomOneofCase.Iceberg),
|
|
init_format: AlgoFormats.Attachable,
|
|
editing_permissions: AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowEditValues));
|
|
_settings_manager = settings_manager;
|
|
_columns = new OrderBookColumnCollection(bus, model, model.on_order_securities.Select(x => (x.added.Values, x.removed.Values)));
|
|
// we use an ObservableAppendCollection b/c the mini-ob needs a cancel column at the front
|
|
columns = new ObservableAppendCollection<DIYGrid.ColumnBase>(_columns);
|
|
_row_collection = new OperableHierarchicalCollection<OrderBookRowVM, OrderSecurity, uint>(
|
|
o => new OrderBookRowVM(this, o, rows_are_initially_expanded) {
|
|
is_attachable = _cached_attachable.TryGetValue(o.order.Key, out bool ia) && ia,
|
|
is_detachable = _cached_detachable.TryGetValue(o.order.Key, out bool id)
|
|
},
|
|
r => r.order.Key,
|
|
r => r.order.ParentKey,
|
|
_columns.get_sorting_data().comparer);
|
|
_row_collection.CollectionChanged += _row_collection_CollectionChanged;
|
|
_current_row = backing<OrderBookRowVM>(nameof(current_row));
|
|
_columns.filter_changed += _on_filter_changed;
|
|
collapse_all_rows_command = new DelegateCommand(_row_collection.collapse_all);
|
|
expand_all_rows_command = new DelegateCommand(_row_collection.expand_all);
|
|
var modify_selected_orders_async_cmd = new AsyncCommand(_modify_selected_orders_async, () => _selected_params_mon.all_active && order_mod_vm.is_dirty);
|
|
modify_selected_orders_cmd = modify_selected_orders_async_cmd;
|
|
var revert_selected_orders_cmd = new DelegateCommand(order_mod_vm.revert, () => _selected_params_mon.all_active && order_mod_vm.is_dirty);
|
|
this.revert_selected_orders_cmd = revert_selected_orders_cmd;
|
|
var send_attached_orders_async_cmd = new ObservantAsyncCommand(send_attached_orders_async);
|
|
send_attached_orders_cmd = send_attached_orders_async_cmd;
|
|
cancel_attach_orders_cmd = new DelegateCommand(() => is_attaching_orders = false);
|
|
var begin_attach_cmd = new ObservantCommand(begin_attach_algos);
|
|
this.begin_attach_cmd = begin_attach_cmd;
|
|
var detach_selected_orders_async_cmd = new ObservantAsyncCommand(() => _detach_orders_async(selected_rows));
|
|
detach_selected_orders_cmd = detach_selected_orders_async_cmd;
|
|
toggle_show_right_panel_cmd = new DelegateCommand(() => show_right_panel = !show_right_panel);
|
|
toggle_show_fills_cmd = new DelegateCommand(() => show_fills = !show_fills);
|
|
launch_fills_settings_cmd = concated_disposable(new DialogCommand(() => {
|
|
const string title = "Order Book 'Mini' Fills Grid";
|
|
var vm = new WindowSettingsDialogVM<GridSettings, SimpleGridSettingsVM>(
|
|
_fills_settings_manager,
|
|
us => us.fills_grid,
|
|
UserSettings.FileExtensions.GRID,
|
|
s => fills_vm.value.grid_settings_manager.create_vm(
|
|
// we need to get the most up to date GridSettings when launching b/c users may
|
|
// have changed some settings on the grid directly, like column widths.
|
|
s.with(fills_vm.columns.Select(c => c.create())),
|
|
Observable.Return(title)
|
|
),
|
|
show_save_as_defaults: false);
|
|
// TODO: bind to main window's Title
|
|
var dialog = new SimpleGridSettingsDialog { Title = title, DataContext = vm };
|
|
vm.RequestClose += (s, e) => WindowUtilities.force_close(dialog);
|
|
return dialog;
|
|
}));
|
|
grid_settings_manager = new OrderBookGridSettingsManager(owner_title, bus, notification_service, model, rows, columns);
|
|
grid_settings_manager.algo_tree_display_mode_changed += _on_filter_changed;
|
|
IDisposable attach_vm_hooks = null;
|
|
begin_attaching += on_begin_attaching;
|
|
end_attaching += on_end_attaching;
|
|
// switch between orders and/or orders w/ piq
|
|
var orders_source = OrdersModel.piq_enabled ? model.on_order_tuples_with_root_and_piq : model.on_order_tuples_with_root;
|
|
concat_disposable(
|
|
connect_order_mod_vm(),
|
|
_can_attach_selected_orders.observe_current().Subscribe(send_attached_orders_async_cmd, begin_attach_cmd),
|
|
_can_detach_selected_orders.observe_current().Subscribe(detach_selected_orders_async_cmd),
|
|
_show_ladder.Subscribe(ch => {
|
|
if (ch.newval && ladder_height < _min_ladder_height)
|
|
ladder_height = _min_ladder_height;
|
|
}),
|
|
_show_order_params.Subscribe(ch => {
|
|
if (ch.newval && order_params_height < _min_order_params_height)
|
|
order_params_height = _min_order_params_height;
|
|
}),
|
|
_show_fills.Subscribe(ch => {
|
|
if (ch.newval && fills_height < _min_fills_height)
|
|
fills_height = _min_fills_height;
|
|
}),
|
|
_selected_params_mon.subscribe_all_active().Subscribe(on_all_selected_orders_active_changed),
|
|
_selected_params_mon.subscribe_security_plurality().Subscribe(p => {
|
|
security_plurality = p;
|
|
RaisePropertyChanged(nameof(security_plurality));
|
|
}),
|
|
orders_source.OnDispatcher().Subscribe(t => {
|
|
_cached_orders = t.state;
|
|
_row_collection.update(t.added, t.changed, t.removed.Select(o => o.order.Key));
|
|
}),
|
|
model.on_orders_can_attach.OnDispatcher().Subscribe(table => {
|
|
_cached_attachable = new MappedDictionary<uint, KeyValuePair<uint, bool>, bool>(table.state, kv => kv.Value);
|
|
foreach (var kv in table.added.Concat(table.changed)) {
|
|
if (_row_collection.TryGetRow(kv.Key, out var row)) {
|
|
row.is_attachable = kv.Value;
|
|
if (row.is_selected) {
|
|
if (kv.Value) {
|
|
_attachable_selected_orders.Add(kv.Key);
|
|
} else _attachable_selected_orders.Remove(kv.Key);
|
|
}
|
|
}
|
|
}
|
|
_can_attach_selected_orders.refresh();
|
|
}),
|
|
model.on_orders_can_detach.OnDispatcher().Subscribe(table => {
|
|
_cached_detachable = new MappedDictionary<uint, KeyValuePair<uint, bool>, bool>(table.state, kv => kv.Value);
|
|
foreach (var kv in table.added.Concat(table.changed)) {
|
|
if (_row_collection.TryGetRow(kv.Key, out var row)) {
|
|
row.is_detachable = kv.Value;
|
|
if (row.is_selected) {
|
|
if (kv.Value) {
|
|
_detachable_selected_orders.Add(kv.Key);
|
|
} else _detachable_selected_orders.Remove(kv.Key);
|
|
}
|
|
}
|
|
}
|
|
_can_detach_selected_orders.refresh();
|
|
}),
|
|
grid_settings_manager,
|
|
order_mod_vm.algo_vm.connect_data(Observable.Return(model)),
|
|
order_mod_vm.algo_vm.connect_data(_selected_params_mon.subscribe_spreader_security()),
|
|
order_mod_vm.algo_vm,
|
|
bus.subscribe(SparkTags.SecuritiesTag).OnDispatcher().Subscribe(_selected_params_mon.on_security_md_map),
|
|
attach_vm,
|
|
_show_fills.observe_current(true)
|
|
.Subscribe(is_visible => {
|
|
if (is_visible) {
|
|
var init = _cached_fills_settings.to_startup_data();
|
|
fills_vm.value = new FillsVM(bus, model, Observable.Return(init), model.on_fill_tuples.Filter(mk_fills_slave_predicate_src(), ft => ft.fill.FillKey, _ => false), _fills_settings_manager);
|
|
} else if (fills_vm.value != null) {
|
|
_cached_fills_settings = _get_fills_settings(fills_vm.value);
|
|
fills_vm.value = null;
|
|
}
|
|
}),
|
|
Disposable.Create(() => {
|
|
_columns.filter_changed -= _on_filter_changed;
|
|
grid_settings_manager.algo_tree_display_mode_changed -= _on_filter_changed;
|
|
_row_collection.CollectionChanged -= _row_collection_CollectionChanged;
|
|
begin_attaching -= on_begin_attaching;
|
|
end_attaching -= on_end_attaching;
|
|
Disposable.dispose(ref attach_vm_hooks);
|
|
}),
|
|
_columns);
|
|
if (settings_manager != null) {
|
|
concat_disposable(settings_manager.subscribe_current().OnDispatcher().Subscribe(grid_settings_manager));
|
|
}
|
|
IObservable<Func<FillTuple, bool>> mk_fills_slave_predicate_src() =>
|
|
Observable.Create<Func<FillTuple, bool>>(o => {
|
|
notify();
|
|
return _subscribe_throttled_selected_rows().OnDispatcher().Subscribe(_ => notify());
|
|
void notify() {
|
|
var keys = new HashSet<uint>(selected_hierarchical_rows.Select(r => r.order_key));
|
|
o.OnNext(new Func<FillTuple, bool>(ft => keys.Contains(ft.fill.OrderKey)));
|
|
}
|
|
});
|
|
|
|
void on_all_selected_orders_active_changed(bool newval) {
|
|
order_mod_vm.on_all_active_changed();
|
|
attach_vm?.on_all_active_changed();
|
|
modify_selected_orders_async_cmd.RaiseCanExecuteChanged();
|
|
revert_selected_orders_cmd.RaiseCanExecuteChanged();
|
|
can_user_modify_selected_orders = newval;
|
|
RaisePropertyChanged(nameof(can_user_modify_selected_orders));
|
|
}
|
|
|
|
async Task send_attached_orders_async() {
|
|
is_attaching_orders = false;
|
|
try {
|
|
double price = attach_vm.price;
|
|
uint? size = attach_vm.size;
|
|
uint algo_template_key = attach_vm.algo_vm.algo_root.id.is_persisted ? attach_vm.algo_vm.algo_root.id.persisted.id_uint : 0u;
|
|
var order_tups = selected_rows.Select(r => r.order_tuple).ToList();
|
|
var mod_algo_vm = attach_vm.algo_vm.algo_root;
|
|
await Task.WhenAll(order_tups.Select(t => {
|
|
var algo = t.order.Def.CustomDef.actual().CloneToMutable();
|
|
mod_algo_vm.assign_to(algo);
|
|
if (algo_template_key != 0) {
|
|
algo = new CustomOrderDefinition {
|
|
Composite = new CompositeOrderDefinition {
|
|
AlgoTemplateKey = algo_template_key,
|
|
Definition = algo
|
|
}
|
|
};
|
|
}
|
|
return _model.send_order(
|
|
t.order.Def.with(
|
|
attach_target_order_key: t.order.Key,
|
|
custom_def: algo
|
|
),
|
|
double.IsNaN(price) ? t.order.price() : price,
|
|
size ?? t.order.quantity());
|
|
}));
|
|
} catch (Exception ex) {
|
|
Log.Ui.error($"Error sending attached orders: {ex}.");
|
|
}
|
|
}
|
|
|
|
void on_begin_attaching() {
|
|
Disposable.replace(ref attach_vm_hooks,
|
|
Disposable.Create(
|
|
connect_common_selected_params(attach_vm),
|
|
attach_vm.algo_vm.observe_algo_root().Subscribe(algo_root => {
|
|
bool show_price, show_size;
|
|
if (algo_root == null) {
|
|
show_price = false;
|
|
show_size = false;
|
|
} else {
|
|
show_price = AttachConf.show_price(algo_root.order_type);
|
|
show_size = AttachConf.show_size(algo_root.order_type);
|
|
}
|
|
attach_vm.price_permissions = bool_to_perm(show_price);
|
|
attach_vm.size_permissions = bool_to_perm(show_size);
|
|
AlgoParamPermissions bool_to_perm(bool b) =>
|
|
b ? AlgoParamPermissions.ReadWrite : AlgoParamPermissions.None;
|
|
}),
|
|
// custom templates (created by user)
|
|
_model.algo_model.definitions.OnDispatcher().Subscribe(u =>
|
|
AlgoCollectionHelper.update_persisted_definition_wrappers(attach_vm.algo_vm.algo_roots_index, u, mk_factory(true)))));
|
|
// vm factory
|
|
Func<AlgoData, AlgoDefinitionVM> mk_factory(bool connect) =>
|
|
fd => {
|
|
var vm = AlgoDefinitionVM.create(_model, fd, connect, OrderDataHelper.get_algo_format(_selected_params_mon.security?.ContractCase), AlgoEditingPermissions.AllowEditValues);
|
|
vm.selected_format = OrderDataHelper.get_algo_format(_selected_params_mon.security?.ContractCase);
|
|
return vm;
|
|
};
|
|
}
|
|
void on_end_attaching() => Disposable.dispose(ref attach_vm_hooks);
|
|
|
|
IDisposable connect_order_mod_vm() =>
|
|
Disposable.Create(
|
|
_selected_params_mon.subscribe_algos().Subscribe(order_mod_vm.algo_vm.load_many),
|
|
order_mod_vm.subscribe_is_dirty().Subscribe(_ => {
|
|
modify_selected_orders_async_cmd.RaiseCanExecuteChanged();
|
|
revert_selected_orders_cmd.RaiseCanExecuteChanged();
|
|
}),
|
|
connect_common_selected_params(order_mod_vm));
|
|
|
|
IDisposable connect_common_selected_params(OrderParamsVM vm) =>
|
|
Disposable.Create(
|
|
_selected_params_mon.subscribe_security_md().Subscribe(newval => vm.security_md = newval),
|
|
_selected_params_mon.subscribe_price().Subscribe(vm.on_common_price),
|
|
_selected_params_mon.subscribe_size().Subscribe(vm.on_common_size),
|
|
_selected_params_mon.subscribe_account().Subscribe(newval => vm.selected_account = newval));
|
|
}
|
|
|
|
private void _row_collection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
|
|
is_row_collection_populated = _row_collection.Count != 0;
|
|
}
|
|
|
|
public event Action<OrderRecordImmutable?> selected_order_changed;
|
|
public event Action begin_attaching, end_attaching;
|
|
|
|
public ObservableAppendCollection<DIYGrid.ColumnBase> columns { get; }
|
|
public ObservableCollection<DIYGrid.ColumnBase> core_columns => _columns;
|
|
public IReadOnlyObservableCollection<OrderBookRowVM> rows => _row_collection;
|
|
public OrderBookRowVM current_row {
|
|
get => _current_row.Value;
|
|
set {
|
|
_current_row.Value = value;
|
|
// this is so that when the current_row is set to null from
|
|
// the row_vm, we propagate the change up to the OrderBookWindow
|
|
// so that the cancel and modify commands can_execute is updated.
|
|
// Note that this is really only for if/when the edit_xxx columns
|
|
// from the mini-ob are present in regular orderbook, else this is
|
|
// a no-op.
|
|
selected_order_changed?.Invoke(current_order);
|
|
}
|
|
}
|
|
public OrderRecordImmutable? current_order => current_row?.order;
|
|
public AlgoDefinitionVM algo_vm => order_mod_vm.algo_vm;
|
|
public OrderParamsVM order_mod_vm { get; }
|
|
public FillsVMContainer fills_vm { get; } = new FillsVMContainer();
|
|
public OrderParamsVM attach_vm { get; }
|
|
public ObservableCollection<OrderBookRowVM> selected_rows { get; } = new ObservableCollection<OrderBookRowVM>();
|
|
public IEnumerable<OrderRecordImmutable> selected_orders => selected_rows.Select(r => r.order);
|
|
public IEnumerable<OrderBookRowVM> selected_hierarchical_rows => selected_rows.SelectMany(r => new[] { r }.Concat(_row_collection.get_descendent_rows(r.order_key)));
|
|
public OrderBookGridSettingsManager grid_settings_manager { get; }
|
|
public bool is_attaching_orders {
|
|
get => _is_attaching_orders;
|
|
set {
|
|
if (Set(ref _is_attaching_orders, value))
|
|
(value ? begin_attaching : end_attaching)?.Invoke();
|
|
}
|
|
}
|
|
public ICommand collapse_all_rows_command { get; }
|
|
public ICommand expand_all_rows_command { get; }
|
|
public ICommand modify_selected_orders_cmd { get; }
|
|
public ICommand revert_selected_orders_cmd { get; }
|
|
public ICommand send_attached_orders_cmd { get; }
|
|
public ICommand cancel_attach_orders_cmd { get; }
|
|
public ICommand begin_attach_cmd { get; }
|
|
public ICommand detach_selected_orders_cmd { get; }
|
|
public ICommand toggle_show_right_panel_cmd { get; }
|
|
public ICommand toggle_show_fills_cmd { get; }
|
|
public ICommand launch_fills_settings_cmd { get; }
|
|
public bool show_right_panel {
|
|
get => _show_right_panel;
|
|
set {
|
|
if (Set(ref _show_right_panel, value) && value && !(show_order_params || show_ladder || show_fills))
|
|
show_order_params = true;
|
|
}
|
|
}
|
|
public OrderBookRightPanelSettings.ViewMode right_panel_view_mode {
|
|
get => _right_panel.mode;
|
|
set {
|
|
_right_panel.mode = value;
|
|
RaisePropertyChanged();
|
|
}
|
|
}
|
|
public double right_panel_width {
|
|
get => Math.Max(_raw_right_panel_width, _min_right_panel_width);
|
|
set => Set(ref _raw_right_panel_width, value);
|
|
}
|
|
public double order_params_height {
|
|
get => _order_params_height;
|
|
set => Set(ref _order_params_height, value);
|
|
}
|
|
public double fills_height {
|
|
get => _fills_height;
|
|
set => Set(ref _fills_height, value);
|
|
}
|
|
public double ladder_height {
|
|
get => _ladder_height;
|
|
set => Set(ref _ladder_height, value);
|
|
}
|
|
public bool is_row_collection_populated {
|
|
get => _is_row_collection_populated;
|
|
set => Set(ref _is_row_collection_populated, value);
|
|
}
|
|
public bool show_order_params { get => _show_order_params.Value; set => _right_panel.on_checked(OrderBookRightPanelSettings.Components.Params, value); }
|
|
public bool show_ladder { get => _show_ladder.Value; set => _right_panel.on_checked(OrderBookRightPanelSettings.Components.Ladder, value); }
|
|
public bool show_fills { get => _show_fills.Value; set => _right_panel.on_checked(OrderBookRightPanelSettings.Components.Fills, value); }
|
|
public bool can_user_modify_selected_orders { get; private set; }
|
|
public bool can_attach_selected_orders => _can_attach_selected_orders.Value;
|
|
public bool can_detach_selected_orders => _can_detach_selected_orders.Value;
|
|
public Plurality security_plurality { get; private set; }
|
|
|
|
public IObservable<bool> subscribe_show_fills() => _show_fills.observe_current(true);
|
|
public IObservable<bool> subscribe_show_ladder() => _show_ladder.observe_current(true);
|
|
public IObservable<bool> subscribe_show_order_params() => _show_order_params.observe_current(true);
|
|
|
|
public void row_selection_changed(SelectionChangedEventArgs e) {
|
|
try {
|
|
using (_selected_params_mon.begin_udpate()) {
|
|
if (e.RemovedItems != null) {
|
|
foreach (var row_vm in e.RemovedItems.OfType<OrderBookRowVM>()) {
|
|
row_vm.is_selected = false;
|
|
_selected_params_mon.on_row_unselected(row_vm);
|
|
_attachable_selected_orders.Remove(row_vm.order_key);
|
|
_detachable_selected_orders.Remove(row_vm.order_key);
|
|
}
|
|
}
|
|
if (e.AddedItems != null) {
|
|
foreach (var row_vm in e.AddedItems.OfType<OrderBookRowVM>()) {
|
|
row_vm.is_selected = true;
|
|
_selected_params_mon.on_row_selected(row_vm);
|
|
if (row_vm.is_attachable)
|
|
_attachable_selected_orders.Add(row_vm.order_key);
|
|
if (row_vm.is_detachable)
|
|
_detachable_selected_orders.Add(row_vm.order_key);
|
|
}
|
|
}
|
|
RowSelectionHelper.apply_changes(selected_rows, e);
|
|
_can_attach_selected_orders.refresh();
|
|
_can_detach_selected_orders.refresh();
|
|
selected_order_changed?.Invoke(current_order);
|
|
}
|
|
} catch(Exception ex) {
|
|
// [John]I observed a strange null-reference exception in this callback when the launcher was shutting down (see https://bluetradesys.atlassian.net/browse/SPARK-2089)
|
|
Log.Ui.error($"[{nameof(OrderBookVM)}] Error handling selection change: {ex}");
|
|
}
|
|
}
|
|
|
|
public OrderBookStartupData create() {
|
|
var (filters, sorting) = _columns.create();
|
|
var gs = grid_settings_manager.create(sorting);
|
|
var rv = new OrderBookStartupData(
|
|
filters,
|
|
gs,
|
|
_show_right_panel,
|
|
_raw_right_panel_width,
|
|
_fills_height,
|
|
show_fills,
|
|
use_defaults: _settings_manager.instance_settings == null) {
|
|
order_params_height = order_params_height,
|
|
show_ladder = show_ladder,
|
|
show_order_params = show_order_params,
|
|
ladder_height = ladder_height,
|
|
fills_settings = _get_fills_settings(fills_vm.value)
|
|
};
|
|
rv.right_panel.mode = right_panel_view_mode;
|
|
rv.right_panel.tab = _right_panel.last_selected;
|
|
return rv;
|
|
}
|
|
|
|
public void load_from(OrderBookStartupData state) {
|
|
if (state == null) return;
|
|
/// important: <see cref="_cached_fills_settings"/> must be assigned before <see cref="show_fills"/>, as the former is used to create the fills vm immediately after <see cref="show_fills"/> is set to true.
|
|
if (state.fills_settings != null) {
|
|
_cached_fills_settings = state.fills_settings;
|
|
_fills_settings_manager.instance_settings = state.fills_settings.general;
|
|
}
|
|
right_panel_view_mode = state.right_panel.mode;
|
|
show_right_panel = state.right_panel.show;
|
|
switch (state.right_panel.mode) {
|
|
case OrderBookRightPanelSettings.ViewMode.Stack:
|
|
show_order_params = state.right_panel.stack.show_order_params;
|
|
show_ladder = state.right_panel.stack.show_ladder;
|
|
show_fills = state.right_panel.stack.show_fills;
|
|
break;
|
|
case OrderBookRightPanelSettings.ViewMode.Tab:
|
|
_right_panel.on_checked(state.right_panel.tab, true);
|
|
break;
|
|
}
|
|
fills_height = state.fills_height;
|
|
ladder_height = state.ladder_height;
|
|
var gs = state.grid_settings_wrapper();
|
|
if (gs != null) {
|
|
grid_settings_manager.load_from(gs);
|
|
}
|
|
(var old_filter, var old_sort) = _columns.create();
|
|
// suspend column filter updates
|
|
_columns.filter_changed -= _on_filter_changed;
|
|
grid_settings_manager.algo_tree_display_mode_changed -= _on_filter_changed;
|
|
#pragma warning disable CS0612 // Type or member is obsolete
|
|
_columns.load_from((state.filters, (state.orderbook_grid?.general ?? OrderBookStartupData.DefaultGrid.general).sorting_criterion));
|
|
#pragma warning restore CS0612 // Type or member is obsolete
|
|
// resume column filter updates
|
|
_columns.filter_changed += _on_filter_changed;
|
|
grid_settings_manager.algo_tree_display_mode_changed += _on_filter_changed;
|
|
var new_filter = new FilterData(grid_settings_manager.algo_tree_display_mode, _columns.create_filter_states());
|
|
var new_sort = _columns.get_sorting_data();
|
|
if (!new_filter.Equals(_cached_filter_data)) {
|
|
_cached_filter_data = new_filter;
|
|
if (!new_sort.Equals(old_sort)) {
|
|
/// Both filter and sort have changed, use <see cref="OperableHierarchicalCollection{TRow, T, TKey}.defer_refresh"/> to avoid syncing twice.
|
|
using (_row_collection.defer_refresh()) {
|
|
_row_collection.filter = new_filter.build_predicate();
|
|
_row_collection.comparer = new_sort.comparer;
|
|
}
|
|
} else {
|
|
_row_collection.filter = new_filter.build_predicate();
|
|
}
|
|
} else if (!new_sort.Equals(old_sort))
|
|
_row_collection.comparer = new_sort.comparer;
|
|
}
|
|
|
|
public void on_sorting(object sender, DIYGridSortingEventArgs e) {
|
|
if (e.Column is ICVOrderBookColumn col) {
|
|
e.Handled = true;
|
|
_columns.on_sorting(col, !KeyboardExtensions.IsShiftDown());
|
|
var sorting_data = _columns.get_sorting_data();
|
|
Log.Ui.info($"{nameof(OrderBookRowVM)} begin resort: {sorting_data}");
|
|
_row_collection.comparer = sorting_data.comparer;
|
|
} else {
|
|
Log.Ui.warn($"{nameof(OrderBookVM)} failed to process sorting event: Column was not of type {nameof(ICVOrderBookColumn)}");
|
|
}
|
|
}
|
|
|
|
public void begin_attach_algos() => is_attaching_orders = true;
|
|
|
|
public bool try_get_parent(OrderBookRowVM row, out OrderSecurity parent) =>
|
|
_cached_orders.TryGetValue(row.parent_order_key, out parent);
|
|
|
|
public OrderRecordImmutable get_root(OrderRecordImmutable r) {
|
|
while (r.ParentKey != 0 && _cached_orders.TryGetValue(r.ParentKey, out var parent_osam)) {
|
|
r = parent_osam.order;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
internal void detach_orders(OrderBookRowVM order) =>
|
|
_detach_orders_async(new[] { order }).ignore();
|
|
|
|
public OrderSecurity get_ordersecurityalgometa(OrderRecordImmutable order) {
|
|
_cached_orders.TryGetValue(order.Key, out var osam);
|
|
return osam;
|
|
}
|
|
|
|
public OrderMetadata get_metadata(CustomOrderDefinition.CustomOneofCase order_type) => _model.factory.get_metadata(order_type);
|
|
|
|
public OrderMetadata get_metadata(OrderBookRowVM row) => _model.factory.get_metadata(row.order.actual_order_type());
|
|
|
|
internal OrderBookRowVM get_parent(OrderBookRowVM row) => _row_collection.get_parent(row.order_key);
|
|
|
|
internal void show_order_modify(OrderBookRowVM row) =>
|
|
_bus.post(SparkTags.ShowModifyOrderTag, row.order_key);
|
|
|
|
internal void cancel_order(OrderBookRowVM row) =>
|
|
_bus.post(SparkTags.CancelOrders, new List<uint> { row.order_key });
|
|
|
|
internal void modify_order_quantity(OrderBookRowVM row, uint size) =>
|
|
_bus.post(SparkTags.UpdateOrder, (row.order_key, row.price, size));
|
|
|
|
internal void modify_order_price(OrderBookRowVM row, double price) =>
|
|
_bus.post(SparkTags.UpdateOrder, (row.order_key, price, row.quantity));
|
|
|
|
internal void modify_order_price_and_quantity(OrderBookRowVM row, double price, uint size) =>
|
|
_bus.post(SparkTags.UpdateOrder, (row.order_key, price, size));
|
|
|
|
internal void on_expanded_changed(OrderBookRowVM row) {
|
|
if (row.is_expanded) {
|
|
_row_collection.expand_row(row.order_key);
|
|
} else {
|
|
_row_collection.collapse_row(row.order_key);
|
|
}
|
|
}
|
|
|
|
void _on_filter_changed() {
|
|
var fd = new FilterData(grid_settings_manager.algo_tree_display_mode, _columns.create_filter_states());
|
|
if (!fd.Equals(_cached_filter_data)) {
|
|
_cached_filter_data = fd;
|
|
_row_collection.filter = fd.build_predicate();
|
|
}
|
|
}
|
|
|
|
async Task _detach_orders_async(IEnumerable<OrderBookRowVM> detach_candidates) =>
|
|
await _detach_orders_async(new HashSet<uint>(detach_candidates.Where(r => r.is_detachable).Select(r => r.parent_order_key)));
|
|
|
|
async Task _detach_orders_async(ICollection<uint> keys) {
|
|
Log.Ui.info($"{nameof(OrderBookVM)} begin detaching orders ({keys.Count} total)...");
|
|
try {
|
|
await Task.WhenAll(keys.Select(_model.detach_order));
|
|
} catch (Exception ex) {
|
|
Log.Ui.error($"{nameof(OrderBookVM)} error detaching orders: {ex}.");
|
|
}
|
|
}
|
|
|
|
async Task _modify_selected_orders_async() {
|
|
double? price = DoubleHelper.nan_nullable(order_mod_vm.price);
|
|
uint? size = order_mod_vm.size;
|
|
if (order_mod_vm.algo_vm.algo_root is IAlgoVM mod_algo_vm) {
|
|
// IMPORTANT: Must create ALL the update params before committing ANY.
|
|
// ----
|
|
// As there is no batch update call, each order is updated individually.
|
|
// Once updated, if an order returns in the data-stream before any other orders have been updated,
|
|
// the modified params will become non-uniform for the currently selection (unless the order is filtered out),
|
|
// their values will be cleared (in the param grid gui), and the modifications will not be applied.
|
|
// FYI this behavior is implemented to support 'partial edits.' (e.g., changing the 'price' for multiple orders that do not have the same 'size').
|
|
// ----
|
|
var update_params = selected_rows.Select(update_params_factory).ToList();
|
|
await Task.WhenAll(update_params.Select(t => _model.update_order(t.order, new_price: price, new_size: size, new_algo: t.new_algo)));
|
|
(OrderRecordImmutable order, CustomOrderDefinitionImmutable? new_algo) update_params_factory(OrderBookRowVM row) {
|
|
var mod_algo = row.order.Def.CustomDef.CloneToMutable();
|
|
if (mod_algo.CustomCase == CustomOrderDefinition.CustomOneofCase.Composite) {
|
|
mod_algo_vm.assign_to(mod_algo.Composite.Definition);
|
|
} else {
|
|
mod_algo_vm.assign_to(mod_algo);
|
|
}
|
|
var mod_algoi = new CustomOrderDefinitionImmutable(mod_algo);
|
|
return (row.order, OrderDataHelper.EqualsHelpers.equals(row.order.Def.CustomDef, mod_algoi) ? (CustomOrderDefinitionImmutable?)null : mod_algoi);
|
|
}
|
|
} else await Task.WhenAll(selected_rows.Select(r => _model.update_order(r.order, price)));
|
|
}
|
|
|
|
IObservable<ObservableCollection<OrderBookRowVM>> _subscribe_throttled_selected_rows() =>
|
|
selected_rows.Observe().BufferLatest(TimeSpan.FromSeconds(0.2)).Select(_ => selected_rows);
|
|
|
|
static OrderBookFillsGridSettings _get_fills_settings(FillsVM fills_vm) =>
|
|
fills_vm == null ? OrderBookStartupData.DefaultFillsGrid :
|
|
new OrderBookFillsGridSettings {
|
|
sorting_criterion = fills_vm.get_sorting_criterion().ToList(),
|
|
filters = fills_vm.get_filters(),
|
|
general = fills_vm.grid_settings_manager.create()
|
|
};
|
|
|
|
static OrderRecordTuplePredicate.PredicateTypeOneofCase _corresponding_predicate_type(Columns col) {
|
|
switch (col) {
|
|
case Columns.Security: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Security;
|
|
case Columns.Time: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Time;
|
|
case Columns.LastChange: return OrderRecordTuplePredicate.PredicateTypeOneofCase.LastChange;
|
|
case Columns.User: return OrderRecordTuplePredicate.PredicateTypeOneofCase.User;
|
|
case Columns.Account: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Account;
|
|
case Columns.Exchange: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Exchange;
|
|
case Columns.TimeInForce: return OrderRecordTuplePredicate.PredicateTypeOneofCase.TimeInForce;
|
|
case Columns.OrderType: return OrderRecordTuplePredicate.PredicateTypeOneofCase.OrderType;
|
|
case Columns.SubType: return OrderRecordTuplePredicate.PredicateTypeOneofCase.SubType;
|
|
case Columns.Side: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Side;
|
|
case Columns.Size: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Size;
|
|
case Columns.Price: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Price;
|
|
case Columns.Filled: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Filled;
|
|
case Columns.AvgFilled: return OrderRecordTuplePredicate.PredicateTypeOneofCase.AvgFilled;
|
|
case Columns.LastPrice: return OrderRecordTuplePredicate.PredicateTypeOneofCase.LastPrice;
|
|
case Columns.Status: return OrderRecordTuplePredicate.PredicateTypeOneofCase.Status;
|
|
case Columns.LastMessage: return OrderRecordTuplePredicate.PredicateTypeOneofCase.LastMessage;
|
|
case Columns.SecurityKey: return OrderRecordTuplePredicate.PredicateTypeOneofCase.SecurityKey;
|
|
case Columns.OrderKey: return OrderRecordTuplePredicate.PredicateTypeOneofCase.OrderKey;
|
|
case Columns.ParentKey: return OrderRecordTuplePredicate.PredicateTypeOneofCase.ParentKey;
|
|
case Columns.AttachedTargetOrderKey: return OrderRecordTuplePredicate.PredicateTypeOneofCase.AttachedTargetOrderKey;
|
|
default: return default;
|
|
}
|
|
}
|
|
|
|
static IObservable<ISet<uint>> _subscribe_selected_order_keys(ObservableCollection<OrderBookRowVM> selected_rows) =>
|
|
Observable.Create<ISet<uint>>(o => {
|
|
bool waiting_for_mouse_up = false;
|
|
var sub_container = new DisposableContainer();
|
|
var builder = ImmutableHashSet<uint>.Empty.ToBuilder();
|
|
foreach (var row in selected_rows)
|
|
builder.Add(row.order_key);
|
|
var selected_keys = builder.ToImmutable();
|
|
o.OnNext(selected_keys);
|
|
return Disposable.Create(selected_rows.Subscribe(on_selection_changed), sub_container);
|
|
void on_selection_changed(object sender, NotifyCollectionChangedEventArgs e) {
|
|
if (waiting_for_mouse_up)
|
|
return;
|
|
switch (e.Action) {
|
|
case NotifyCollectionChangedAction.Add:
|
|
case NotifyCollectionChangedAction.Replace:
|
|
foreach (OrderBookRowVM row in e.NewItems)
|
|
selected_keys = selected_keys.Add(row.order_key);
|
|
break;
|
|
case NotifyCollectionChangedAction.Remove:
|
|
foreach (OrderBookRowVM row in e.OldItems)
|
|
selected_keys = selected_keys.Remove(row.order_key);
|
|
break;
|
|
case NotifyCollectionChangedAction.Reset:
|
|
selected_keys = ImmutableHashSet<uint>.Empty;
|
|
break;
|
|
default: return;
|
|
}
|
|
if (Mouse.LeftButton == MouseButtonState.Pressed) {
|
|
waiting_for_mouse_up = true;
|
|
wait_for_mouse_up();
|
|
async void wait_for_mouse_up() {
|
|
await Wait.until_true(() => Mouse.LeftButton == MouseButtonState.Released, TimeSpan.FromSeconds(60), 333);
|
|
builder = ImmutableHashSet<uint>.Empty.ToBuilder();
|
|
foreach (var row in selected_rows)
|
|
builder.Add(row.order_key);
|
|
selected_keys = builder.ToImmutable();
|
|
o.OnNext(selected_keys);
|
|
waiting_for_mouse_up = false;
|
|
}
|
|
} else {
|
|
o.OnNext(selected_keys);
|
|
}
|
|
}
|
|
});
|
|
|
|
public class OrderParamsVM : DisposableViewModelBase {
|
|
readonly SelectorProperty<AccountTuple, AccountTuple?> _accounts;
|
|
readonly OrderBookVM _owner;
|
|
readonly Property<bool> _is_dirty;
|
|
IRaiseCanExecuteChangedCommand _payup_bid_cmd, _payup_ask_cmd;
|
|
IAlgoParamVM<double> _price_param;
|
|
IAlgoParamVM<uint?> _size_param;
|
|
AlgoParamPermissions
|
|
_price_permissions = AlgoParamPermissions.ReadOnly | AlgoParamPermissions.Write,
|
|
_size_permissions = AlgoParamPermissions.ReadOnly | AlgoParamPermissions.Write;
|
|
HashSet<uint> _selected_order_tree = new HashSet<uint>();
|
|
LadderVM _ladder_vm;
|
|
SecurityMD? _security_md;
|
|
|
|
public OrderParamsVM(OrderBookVM owner)
|
|
: this(owner,
|
|
AlgoDefinitionVM.create(
|
|
owner._model,
|
|
new AlgoData(OrderDataHelper.Defaults.CustomOrderDefinitionImmutable(CustomOrderDefinition.CustomOneofCase.Iceberg)),
|
|
editing_permissions: AlgoEditingPermissions.AllowEditValues)) { }
|
|
|
|
public OrderParamsVM(OrderBookVM owner, AlgoDefinitionVM algo_vm) {
|
|
_owner = owner;
|
|
this.algo_vm = algo_vm;
|
|
_accounts = backing(
|
|
nameof(selected_account),
|
|
_model.factory.subscribe_account_tuples(),
|
|
_model.admin_model.on_account_tuples.Where(ts => ts.Count > 0).Select(ts => new InlineUserProperty<AccountTuple>(ts[0])).Take(1),
|
|
a => new AccountTuple?(a),
|
|
() => accounts.Cast<AccountTuple?>().FirstOrDefault(),
|
|
EqualityComparer<AccountTuple?>.Default,
|
|
Array.Empty<PropertyValidation<AccountTuple?>>());
|
|
bbo = new BBOVM { security_md = security_md };
|
|
_payup_bid_cmd = new DelegateCommand<int>(payup_bid, payup_can_execute);
|
|
_payup_ask_cmd = new DelegateCommand<int>(payup_ask, payup_can_execute);
|
|
var algo_param_rows = new ObservableAggregateCollection<AlgoParamRowVM>();
|
|
var appended_param_rows = new ObservableAppendCollection<AlgoParamRowVM>(algo_param_rows);
|
|
param_rows = appended_param_rows;
|
|
var dirty_params_mon = new ReactiveThresholdMonitor<AlgoParamRowVM>(r => r.param.subscribe_is_dirty());
|
|
_is_dirty = backing(nameof(is_dirty), dirty_params_mon);
|
|
_dispose = new CompositeDisposable(bbo, algo_vm,
|
|
AlgoParamRowsHelper.connect(algo_vm, algo_param_rows, false),
|
|
algo_vm.observe_algo_root().Subscribe(root => {
|
|
appended_param_rows.clear_front();
|
|
if (root == null) {
|
|
_price_param = null;
|
|
_size_param = null;
|
|
} else {
|
|
_size_param = new AlgoParamVM<uint?>("size", "Size", owner._selected_params_mon.size) {
|
|
permissions = _size_permissions & _param_permissions
|
|
};
|
|
var price_param = new AlgoParamVM<double>("price", "Price", owner._selected_params_mon.price, spec?.tick_equality_comparer() ?? MathUtils.epsilon_comparer) {
|
|
permissions = _price_permissions & _param_permissions
|
|
};
|
|
_price_param = price_param;
|
|
_price_param.value_changed += on_price_changed;
|
|
void on_price_changed(double oldval, double newval) =>
|
|
price_param.has_value = !double.IsNaN(newval);
|
|
appended_param_rows.insert_front(new AlgoParamRowVM(root, _size_param, null, AlgoParamTemplateKeys.Size));
|
|
appended_param_rows.insert_front(new AlgoParamRowVM(root, _price_param, null, AlgoParamTemplateKeys.Price));
|
|
}
|
|
}),
|
|
ObservableAutoWrapper.connect_item_hooks(param_rows, dirty_params_mon.join),
|
|
owner._subscribe_throttled_selected_rows().OnDispatcher().Subscribe(_ => {
|
|
_selected_order_tree = new HashSet<uint>(_owner.selected_hierarchical_rows.Select(r => r.order_key));
|
|
_reset_ladder_vm();
|
|
})) {
|
|
() => Disposable.dispose(ref _ladder_vm)
|
|
};
|
|
// payup methods
|
|
void payup_bid(int ticks) => payup(bbo.bid, -ticks);
|
|
void payup_ask(int ticks) => payup(bbo.ask, ticks);
|
|
void payup(double from_price, int ticks) {
|
|
if (spec.HasValue && owner._selected_params_mon.all_active)
|
|
price = spec.Value.tickup(from_price, ticks);
|
|
}
|
|
bool payup_can_execute(int ticks) => spec.HasValue && owner._selected_params_mon.all_active;
|
|
}
|
|
|
|
public bool is_dirty => _is_dirty.Value;
|
|
public AlgoParamPermissions price_permissions {
|
|
get => _price_permissions;
|
|
set => _assign_param_permissions(_price_param, ref _price_permissions, value);
|
|
}
|
|
public AlgoParamPermissions size_permissions {
|
|
get => _size_permissions;
|
|
set => _assign_param_permissions(_size_param, ref _size_permissions, value);
|
|
}
|
|
|
|
public ReadOnlyObservableCollection<AccountTuple> accounts => _accounts.items;
|
|
public AccountTuple? selected_account { get => _accounts.selected_item; set => _accounts.selected_item = value; }
|
|
public SecurityImmutable? security => _owner._selected_params_mon.security;
|
|
public SecurityMD? security_md {
|
|
get => _security_md;
|
|
set {
|
|
if (Set(ref _security_md, value)) {
|
|
_reset_ladder_vm();
|
|
RaisePropertyChanged(nameof(security), nameof(spec), nameof(ladder_vm));
|
|
bbo.security_md = value;
|
|
_payup_bid_cmd.RaiseCanExecuteChanged();
|
|
_payup_ask_cmd.RaiseCanExecuteChanged();
|
|
}
|
|
}
|
|
}
|
|
public ContractSpecificationImmutable? spec => security?.ContractSpec;
|
|
public double price {
|
|
get => _price_param?.value ?? double.NaN;
|
|
set {
|
|
if (_price_param != null)
|
|
_price_param.value = value;
|
|
}
|
|
}
|
|
public uint? size {
|
|
get => _size_param?.value;
|
|
set {
|
|
if (_size_param != null)
|
|
_size_param.value = value;
|
|
}
|
|
}
|
|
public AlgoDefinitionVM algo_vm { get; }
|
|
public IReadOnlyObservableCollection<AlgoParamRowVM> param_rows { get; }
|
|
public LadderVM ladder_vm => _ladder_vm;
|
|
public BBOVM bbo { get; }
|
|
public ICommand send_order { get; }
|
|
public ICommand payup_bid_cmd => _payup_bid_cmd;
|
|
public ICommand payup_ask_cmd => _payup_ask_cmd;
|
|
|
|
OrdersModel _model => _owner._model;
|
|
AlgoParamPermissions _param_permissions => _owner._selected_params_mon.all_active ? AlgoParamPermissions.ReadWrite : AlgoParamPermissions.ReadOnly;
|
|
AlgoEditingPermissions _algo_permissions => _owner._selected_params_mon.all_active ? AlgoEditingPermissions.AllowEditValues : AlgoEditingPermissions.None;
|
|
|
|
public void on_common_price(double price) {
|
|
if (_price_param != null) {
|
|
_price_param.value = price;
|
|
_price_param.mark_committed();
|
|
}
|
|
}
|
|
|
|
public void on_common_size(uint? size) {
|
|
if (_size_param != null) {
|
|
_size_param.value = size;
|
|
_size_param.mark_committed();
|
|
}
|
|
}
|
|
|
|
public void on_all_active_changed() {
|
|
algo_vm.editing_permissions_mask = _algo_permissions;
|
|
if (!_owner._selected_params_mon.all_active)
|
|
revert();
|
|
}
|
|
|
|
public void revert() =>
|
|
param_rows.revert_all();
|
|
|
|
public IObservable<bool> subscribe_is_dirty() => _is_dirty.observe_current(true);
|
|
|
|
void _reset_ladder_vm() {
|
|
if (_ladder_vm == null && !_security_md.HasValue)
|
|
return;
|
|
Disposable.replace(ref _ladder_vm,
|
|
_security_md.HasValue ?
|
|
LadderVM.create_readonly(
|
|
_owner._bus,
|
|
new LadderModel(security_md.Value, _owner._model, _owner._model.mbo_service,
|
|
new Func<OrderSecurity, bool>(osec => _selected_order_tree.Contains(osec.order.Key)))) :
|
|
null);
|
|
RaisePropertyChanged(nameof(ladder_vm));
|
|
}
|
|
void _assign_param_permissions<T>(IAlgoParamVM<T> param, ref AlgoParamPermissions permissions_backing, AlgoParamPermissions permissions) {
|
|
if (permissions_backing != permissions) {
|
|
permissions_backing = permissions;
|
|
if (param != null)
|
|
param.permissions = permissions & _param_permissions;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct FilterData : IEquatable<FilterData> {
|
|
public readonly AlgoTreeDisplayMode algo_tree_display_mode;
|
|
public readonly FilterStates column_filters;
|
|
|
|
public FilterData(AlgoTreeDisplayMode algo_tree_display_mode, FilterStates column_filters) {
|
|
this.algo_tree_display_mode = algo_tree_display_mode;
|
|
this.column_filters = column_filters;
|
|
}
|
|
|
|
public Func<OrderSecurity, bool> build_predicate() {
|
|
var pred = column_filters.build_predicate();
|
|
if (algo_tree_display_mode == AlgoTreeDisplayMode.RootAndLeafNodes) {
|
|
if (pred == null) {
|
|
pred = tree_disp_pred;
|
|
} else {
|
|
var col_pred = pred;
|
|
pred = o => tree_disp_pred(o) && col_pred(o);
|
|
}
|
|
bool tree_disp_pred(OrderSecurity o) =>
|
|
!o.order.has_parent() ||
|
|
o.order.is_exchange_order() ||
|
|
o.order.order_type() == CustomOrderDefinition.CustomOneofCase.Spreader;
|
|
}
|
|
return pred;
|
|
}
|
|
|
|
public bool Equals(FilterData other) =>
|
|
algo_tree_display_mode == other.algo_tree_display_mode &&
|
|
column_filters.safe_equals(other.column_filters);
|
|
|
|
public override bool Equals(object obj) =>
|
|
obj is FilterData fd && Equals(fd);
|
|
|
|
public override int GetHashCode() =>
|
|
EqualityComparer.aggregate_hash((int)algo_tree_display_mode, column_filters?.GetHashCode() ?? 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Monitors selected rows, and determines whether or not they are all active-orders, with common parameters.
|
|
/// </summary>
|
|
class SelectedOrderParamsMon {
|
|
static readonly TimeSpan _throttle = TimeSpan.FromSeconds(0.1);
|
|
readonly CommonValueGroupMonitor<AlgoSecurityKey, AlgoSecurityKey> _algo_def_mon =
|
|
new CommonValueGroupMonitor<AlgoSecurityKey, AlgoSecurityKey>(
|
|
ask => ask,
|
|
EqualityComparer<AlgoSecurityKey>.Default,
|
|
EqualityComparer.Create<AlgoSecurityKey, CustomOrderDefinitionImmutable>(ask => ask.algo, OrderDataHelper.EqualsHelpers.custom_order_def_compareri));
|
|
readonly CommonValueMonitor<SecurityImmutable?> _spreader_security_mon = new CommonValueMonitor<SecurityImmutable?>();
|
|
readonly CommonValueMonitor<SecurityImmutable?> _security_mon = new CommonValueMonitor<SecurityImmutable?>();
|
|
readonly CommonValueMonitor<double> _price_mon = new CommonValueMonitor<double>(double.NaN);
|
|
readonly CommonValueMonitor<uint> _size_mon = new CommonValueMonitor<uint>();
|
|
readonly CommonValueMonitor<AccountTuple> _account_mon = new CommonValueMonitor<AccountTuple>();
|
|
readonly CommonValueMonitor<bool> _all_active_mon = new CommonValueMonitor<bool>();
|
|
readonly CommonValueMonitorMultiplexor<OrderSecurity> _group_mon = new CommonValueMonitorMultiplexor<OrderSecurity>();
|
|
readonly DynamicOrderHelper _dyn_helper;
|
|
IReadOnlyDictionary<uint, SecurityMD> _security_md_map = DictionaryHelper.empty<uint, SecurityMD>();
|
|
|
|
public SelectedOrderParamsMon(DynamicOrderHelper dyn_helper) {
|
|
_dyn_helper = dyn_helper;
|
|
_group_mon.add_member_mon(_algo_def_mon, _algo_key);
|
|
_group_mon.add_member_mon(_spreader_security_mon, _get_spreader_sec, s => s.HasValue);
|
|
_group_mon.add_member_mon(_security_mon, osam => osam.security, s => s.HasValue);
|
|
_group_mon.add_member_mon(_price_mon, osam => osam.order.price());
|
|
_group_mon.add_member_mon(_size_mon, osam => osam.order.quantity());
|
|
_group_mon.add_member_mon(_account_mon, osam => new AccountTuple(osam.order.account_id(), osam.order.account()));
|
|
_group_mon.add_member_mon(_all_active_mon, osam => osam.order.is_active());
|
|
}
|
|
|
|
event Action _security_md_map_changed;
|
|
|
|
public SecurityImmutable? security => _security_mon.common_value;
|
|
public SecurityMD? security_md => security is SecurityImmutable sec && _security_md_map.TryGetValue(sec.Id, out SecurityMD smd) ? smd : (SecurityMD?)null;
|
|
public SecurityImmutable? spreader_security => _spreader_security_mon.common_value;
|
|
public double price => _price_mon.try_get_common_value(out double p) ? p : double.NaN;
|
|
public uint? size => _size_mon.common_value_nullable();
|
|
public AccountTuple? account => _account_mon.common_value_nullable();
|
|
public bool all_active => _all_active_mon.common_value;
|
|
|
|
public IObservable<IEnumerable<CustomOrderDefinitionImmutable>> subscribe_algos() => _algo_def_mon.SubscribeThrottled(_throttle, (ask, vals) => vals.Select(v => v.algo), Enumerable.Empty<CustomOrderDefinitionImmutable>());
|
|
public IObservable<SecurityImmutable?> subscribe_spreader_security() => _spreader_security_mon.SubscribeThrottled(_throttle);
|
|
public IObservable<SecurityImmutable?> subscribe_security() => _security_mon.SubscribeThrottled(_throttle);
|
|
public IObservable<SecurityMD?> subscribe_security_md() =>
|
|
Observable.Create<SecurityMD?>(o => {
|
|
SecurityMD? last_value = security_md;
|
|
o.OnNext(last_value);
|
|
_security_mon.common_value_changed += on_common_sec_changed;
|
|
_security_md_map_changed += refresh;
|
|
return Disposable.Create(() => {
|
|
_security_mon.common_value_changed -= on_common_sec_changed;
|
|
_security_md_map_changed -= refresh;
|
|
});
|
|
void on_common_sec_changed(SecurityImmutable? _) => refresh();
|
|
void refresh() {
|
|
var curr = security_md;
|
|
if (curr != last_value)
|
|
o.OnNext(last_value = curr);
|
|
}
|
|
});
|
|
public IObservable<double> subscribe_price() => _price_mon.SubscribeThrottled(_throttle);
|
|
public IObservable<uint?> subscribe_size() => _size_mon.SubscribeThrottledNullable(_throttle);
|
|
public IObservable<AccountTuple?> subscribe_account() => _account_mon.SubscribeThrottledNullable(_throttle);
|
|
public IObservable<bool> subscribe_all_active() => _all_active_mon.SubscribeThrottled(_throttle);
|
|
public IObservable<Plurality> subscribe_security_plurality() => _security_mon.SubscribePluralityThrottled(_throttle);
|
|
|
|
public IDisposable begin_udpate() =>
|
|
_group_mon.defer_updates();
|
|
|
|
public void on_row_selected(OrderBookRowVM row) {
|
|
_group_mon.add(row.order_tuple);
|
|
row.updated += _on_row_updated;
|
|
}
|
|
|
|
public void on_row_unselected(OrderBookRowVM row) {
|
|
_group_mon.remove(row.order_tuple);
|
|
row.updated -= _on_row_updated;
|
|
}
|
|
|
|
public void on_security_md_map(IReadOnlyDictionary<uint, SecurityMD> security_md_map) {
|
|
_security_md_map = security_md_map;
|
|
_security_md_map_changed?.Invoke();
|
|
}
|
|
|
|
void _on_row_updated((OrderSecurity oldval, OrderSecurity newval) ch) {
|
|
using (begin_udpate()) {
|
|
_group_mon.remove(ch.oldval);
|
|
_group_mon.add(ch.newval);
|
|
}
|
|
}
|
|
|
|
static SecurityImmutable? _get_spreader_sec(OrderSecurity osam) =>
|
|
OrderDataHelper.enumerate_algo_hierarchy(osam.order.Def.CustomDef.CloneToMutable())
|
|
.Any(algo => algo.CustomCase == CustomOrderDefinition.CustomOneofCase.Spreader) ?
|
|
osam.security : null;
|
|
|
|
AlgoSecurityKey _algo_key(OrderSecurity osam) =>
|
|
new AlgoSecurityKey(osam.order.Def.CustomDef, _get_spreader_sec(osam), AlgoStructureSerializer.structure_key(osam.order.Def.CustomDef, _dyn_helper.dynamic_type_index));
|
|
|
|
SecurityMD? _get_sec_md(OrderSecurity osam) =>
|
|
osam.security.HasValue && _security_md_map.TryGetValue(osam.security.Value.Id, out SecurityMD smd) ? smd : (SecurityMD?)null;
|
|
|
|
struct AlgoSecurityKey {
|
|
public readonly CustomOrderDefinitionImmutable algo;
|
|
public readonly SecurityImmutable? security;
|
|
public readonly AlgoStructureKey key;
|
|
|
|
public AlgoSecurityKey(CustomOrderDefinitionImmutable algo, SecurityImmutable? security, AlgoStructureKey key) {
|
|
this.algo = algo;
|
|
this.security = security;
|
|
this.key = key;
|
|
}
|
|
|
|
public bool Equals(AlgoSecurityKey other) =>
|
|
security == other.security &&
|
|
key == other.key;
|
|
|
|
public override bool Equals(object obj) => obj is AlgoSecurityKey other && Equals(other);
|
|
public override int GetHashCode() => key.GetHashCode();
|
|
|
|
public static bool operator ==(AlgoSecurityKey a, AlgoSecurityKey b) => a.Equals(b);
|
|
public static bool operator !=(AlgoSecurityKey a, AlgoSecurityKey b) => !a.Equals(b);
|
|
}
|
|
}
|
|
|
|
class RightPanelModel {
|
|
OrderBookRightPanelSettings.ViewMode _mode;
|
|
OrderBookRightPanelSettings.Components _all_selected, _hidden = OrderBookRightPanelSettings.Components.None;
|
|
|
|
public event Action<OrderBookRightPanelSettings.Components> visible_changed;
|
|
|
|
public OrderBookRightPanelSettings.Components last_selected { get; private set; }
|
|
|
|
public OrderBookRightPanelSettings.ViewMode mode {
|
|
get => _mode;
|
|
set {
|
|
using (_update()) {
|
|
if (_mode == OrderBookRightPanelSettings.ViewMode.Stack && value == OrderBookRightPanelSettings.ViewMode.Tab) {
|
|
if (last_selected == OrderBookRightPanelSettings.Components.None)
|
|
last_selected = EnumHelper.get_values_except(OrderBookRightPanelSettings.Components.None).FirstOrDefault(c => (c & _all_selected) != 0);
|
|
}
|
|
_mode = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public OrderBookRightPanelSettings.Components visible_components {
|
|
get {
|
|
switch (mode) {
|
|
case OrderBookRightPanelSettings.ViewMode.Stack: return _all_selected ^ (_all_selected & _hidden);
|
|
case OrderBookRightPanelSettings.ViewMode.Tab: return last_selected;
|
|
default: return OrderBookRightPanelSettings.Components.None;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void on_checked(OrderBookRightPanelSettings.Components component, bool is_checked) {
|
|
using (_update()) {
|
|
if (is_checked) {
|
|
_hidden ^= (_hidden & component);
|
|
_all_selected |= component;
|
|
last_selected = component;
|
|
} else if (mode == OrderBookRightPanelSettings.ViewMode.Stack) {
|
|
last_selected ^= (last_selected & component);
|
|
_hidden |= component;
|
|
}
|
|
}
|
|
}
|
|
|
|
IDisposable _update() {
|
|
var prev_vis = visible_components;
|
|
return Disposable.Create(refresh);
|
|
void refresh() {
|
|
if (prev_vis != visible_components)
|
|
visible_changed?.Invoke(visible_components);
|
|
}
|
|
}
|
|
}
|
|
|
|
static class AttachConf {
|
|
static readonly IReadOnlyDictionary<CustomOrderDefinition.CustomOneofCase, (bool show_price, bool show_size)> _algo_type_conf;
|
|
|
|
static AttachConf() {
|
|
var cover = config.Configuration.get<bts.config.CoverAttachUIOptions>();
|
|
var join = config.Configuration.get<bts.config.JoinAttachUIOptions>();
|
|
var lean = config.Configuration.get<bts.config.LeanAttachUIOptions>();
|
|
var top = config.Configuration.get<bts.config.TopAttachUIOptions>();
|
|
_algo_type_conf = new Dictionary<CustomOrderDefinition.CustomOneofCase, (bool, bool)> {
|
|
{ CustomOrderDefinition.CustomOneofCase.Cover, (cover.show_price, cover.show_quantity) },
|
|
{ CustomOrderDefinition.CustomOneofCase.Join, (join.show_price, join.show_quantity) },
|
|
{ CustomOrderDefinition.CustomOneofCase.Lean, (lean.show_price, lean.show_quantity) },
|
|
{ CustomOrderDefinition.CustomOneofCase.Top, (top.show_price, top.show_quantity) }
|
|
};
|
|
}
|
|
|
|
public static bool show_price(CustomOrderDefinition.CustomOneofCase algo_type) =>
|
|
!_algo_type_conf.TryGetValue(algo_type, out var result) || result.show_price;
|
|
|
|
public static bool show_size(CustomOrderDefinition.CustomOneofCase algo_type) =>
|
|
!_algo_type_conf.TryGetValue(algo_type, out var result) || result.show_size;
|
|
}
|
|
}
|
|
}
|