334 lines
16 KiB
C#
334 lines
16 KiB
C#
using bts.api;
|
|
using bts.collections;
|
|
using bts.md;
|
|
using mbts;
|
|
using mbts.config;
|
|
using mbts.persist;
|
|
using mbts.spark;
|
|
using mbts.ui;
|
|
using mbts.ui.shell;
|
|
using mbts.ui.spark;
|
|
using ProtoBuf;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reactive.Linq;
|
|
using System.Reactive.Subjects;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using LadderSettings = mbts.spark.LadderSettings;
|
|
|
|
namespace bts.shell {
|
|
class LadderWindowFactory : ShellWindowFactory<LadderSaveState> {
|
|
const string _window_type = "ladder";
|
|
const int _version_where_stickied_algos_introduced = 2;
|
|
readonly LadderConfig _ladder_conf;
|
|
readonly IBus _bus;
|
|
readonly IWindowManager _wm;
|
|
readonly MBOService _mbo;
|
|
readonly UserSettingsHub _settings_hub;
|
|
readonly OrdersModel _orders_model;
|
|
readonly IShellWindowThreadIDProvider _thread_id_provider;
|
|
IReadOnlyDictionary<uint, SecurityMD> _securities = new Dictionary<uint, SecurityMD>();
|
|
|
|
public LadderWindowFactory(
|
|
IShellModule owner,
|
|
IBus bus,
|
|
IWindowManager wm,
|
|
UserSettingsHub settings_hub,
|
|
OrdersModel orders_model,
|
|
MBOService mbo)
|
|
|
|
: base(owner, "SparkLadder", 2) {
|
|
_bus = bus;
|
|
_wm = wm;
|
|
_settings_hub = settings_hub;
|
|
_orders_model = orders_model;
|
|
_ladder_conf = new LadderConfig(Configuration.get<bts.config.LadderKnobs>(), Configuration.get<bts.config.MultiThreadedWindows>().ladder);
|
|
_thread_id_provider = ShellWindowThreadIDFactory.create("Ladder", _ladder_conf.ladders_on_threads);
|
|
_mbo = mbo;
|
|
_dispose = Disposable.Create(
|
|
bus.subscribe(SparkTags.SecuritiesTag).Subscribe(s => _securities = s),
|
|
bus.subscribe(SparkTags.ShowLadderAutoLookupTag).Subscribe(_show_windows),
|
|
bus.subscribe(SparkTags.ShowLadderTag).OnDispatcher().Subscribe(s => show_windows(new[] { s })),
|
|
bus.subscribe(SparkTags.ShowLaddersTag).OnDispatcher().Subscribe(show_windows)
|
|
);
|
|
}
|
|
|
|
public async override Task<IShellWindow> load(LadderSaveState state) {
|
|
await Wait.until_true(() => _securities.ContainsKey(state.security_key), _ladder_conf.security_timeout);
|
|
if (_securities.TryGetValue(state.security_key, out SecurityMD security)) {
|
|
return create_ladder_window(security, state.settings, state.settings_id);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override Task<IShellWindow> try_upgrade_state(Stream load_stream, int version) {
|
|
var state = ProtoBuf.Serializer.DeserializeWithLengthPrefix<LadderSaveState>(load_stream, ProtoBuf.PrefixStyle.Fixed32);
|
|
if (version < _version_where_stickied_algos_introduced) {
|
|
// We want to assign any existing favorite algos to stickied algos upon setting upgrade
|
|
var favorite_algos_array = state.settings.favorite_algos.favorite_algos.ToArray();
|
|
state.settings.favorite_algos = new LadderFavoriteAlgosSettings(
|
|
favorite_algos_array,
|
|
state.settings.favorite_algos.column_count,
|
|
favorite_algos_array,
|
|
state.settings.favorite_algos.auto_revert_algos.ToArray());
|
|
}
|
|
return load(state);
|
|
}
|
|
|
|
LadderSaveState _get_state(LadderVM vm, uint id) {
|
|
LadderSettings s = vm.get_save_state();
|
|
if (id != 0) {
|
|
if (!_settings_hub.current.ladder_profiles.TryGetFirst(lp => lp.id == id, out var result)) {
|
|
// profile was deleted
|
|
id = 0;
|
|
} else if (!LadderSettings.profile_equals(s, result.value)) {
|
|
// ladder's settings diverged from the profile (this happens when the user changes settings outside of the settings dialog, such as column widths, left panel width, etc.)
|
|
id = 0;
|
|
}
|
|
}
|
|
return new LadderSaveState { security_key = vm.security.Id, settings = s, settings_id = id };
|
|
}
|
|
|
|
IShellWindow create_ladder_window(SecurityMD md, LadderSettings last_value, uint settings_id = 0) {
|
|
IDisposable active_settings_dialog = null;
|
|
// on_shell_window_vm should behave like an event (do not set to null)
|
|
Action<ShellWindowVM> on_shell_window_vm = _ => { };
|
|
ShellWindowVM shell_window_vm = null;
|
|
IShellWindow shell_window = null;
|
|
var title_source = new LazyObservable<string>(() => ShellWindowExtensions.literal_title_source(shell_window, shell_window_vm));
|
|
LadderVM vm = null;
|
|
var view = new Lazy<UIElement>(() => {
|
|
// resources
|
|
var model = new LadderModel(md, _orders_model, _mbo);
|
|
var profile_service = new SettingsProfileService<LadderSettings>(_settings_hub,
|
|
us => ImmutableDictionary<uint, SettingsProfile<LadderSettings>>.Empty.AddRange(us.ladder_profiles.ToDictionary(
|
|
lp => lp.id,
|
|
lp => new SettingsProfile<LadderSettings>(lp.id, lp.name, LadderSettings.sanitize(lp.value), lp.security_criteria))),
|
|
(us, lps) => us.with(ladder_profiles: lps.Values.Select(lp => new LadderSettingsProfile(lp.id, lp.name, lp.value, lp.security_criteria)).ToArray()));
|
|
last_value?.sanitize();
|
|
/// When settings are adjusted outside of the settings dialog, the vm should raise the <see cref="LadderVM.settings_invalidated"/> event.
|
|
/// In response to that event, 'needs_resync' is set to true. This causes 'last_value' to be refreshed when the next caller requests the latest settings
|
|
/// (i.e., an IObserver subscribing to the settings_source, or the settings-dialog viewmodel).
|
|
bool initialized = false, needs_resync = false;
|
|
var settings_subject = new Subject<LadderSettings>();
|
|
var settings_source = Observable.Create<LadderSettings>(o => {
|
|
ensure_synced();
|
|
if (last_value != null)
|
|
o.OnNext(last_value);
|
|
return settings_subject.Subscribe(s => {
|
|
if (s != null)
|
|
o.OnNext(s);
|
|
});
|
|
});
|
|
// vm
|
|
vm = LadderVM.create(_bus, model, LadderSettings.sanitize(last_value ?? _settings_hub.current.ladder), settings_source);
|
|
vm.settings_invalidated += on_settings_invalidated;
|
|
vm.order_properties_vm.open_algo_popup_on_select = _ladder_conf.open_algo_popup_on_select;
|
|
vm.order_properties_vm.use_algo_param_grid = _ladder_conf.use_algo_param_grid;
|
|
vm.request_settings_dialog += open_settings_dialog;
|
|
var settings_subscription = _settings_hub.subscribe_default_settings().Subscribe(on_user_settings);
|
|
vm.OnDisposed += disposing => {
|
|
Disposable.dispose(ref settings_subscription);
|
|
Disposable.dispose(ref active_settings_dialog);
|
|
Disposable.dispose(ref settings_subject);
|
|
};
|
|
// view
|
|
var lv = new LadderView(vm);
|
|
foreach (var kv in AlgoStudioModelUtils.get_dynamic_resources(vm.model.order_gateway.algo_model.ui_configuration))
|
|
lv.Resources[kv.Key] = kv.Value;
|
|
return lv;
|
|
// local methods
|
|
void on_settings_invalidated() =>
|
|
needs_resync = true;
|
|
|
|
void ensure_synced() {
|
|
if (!needs_resync)
|
|
return;
|
|
var curr = vm.get_save_state();
|
|
if (settings_id == 0) {
|
|
last_value = curr;
|
|
} else if (!LadderSettings.profile_equals(curr, last_value)) {
|
|
settings_id = 0;
|
|
last_value = curr;
|
|
}
|
|
needs_resync = false;
|
|
}
|
|
|
|
void on_user_settings(UserSettings us) {
|
|
if (initialized) {
|
|
ensure_synced();
|
|
if (settings_id == 0) {
|
|
// not on a profile, don't respond to default settings changes
|
|
return;
|
|
} else if (us.ladder_profiles.TryGetFirst(p => p.id == settings_id, out var profile)) {
|
|
if (!LadderSettings.profile_equals(last_value, vm.get_save_state())) {
|
|
settings_id = 0;
|
|
} else {
|
|
settings_subject.OnNext(last_value = profile.value);
|
|
}
|
|
} else {
|
|
// profile was deleted; keep the current settings and switch to the 'Local' profile.
|
|
settings_id = 0;
|
|
}
|
|
} else if (_settings_hub.initialized) {
|
|
initialized = true;
|
|
if (settings_id != 0) {
|
|
if (us.ladder_profiles.TryGetFirst(p => p.id == settings_id, out var profile)) {
|
|
last_value = profile.value;
|
|
} else {
|
|
settings_id = 0;
|
|
}
|
|
}
|
|
if (settings_id == 0 && last_value == null) {
|
|
foreach (var lp in _settings_hub.current.ladder_profiles) {
|
|
// TODO: Use a kind of 'match priority' to resolve conflicts when the security is included in more than 1 profile's security criteria.
|
|
// In the meantime, simply use the first match.
|
|
if (lp.security_criteria.includes(md.security)) {
|
|
last_value = lp.value;
|
|
settings_id = lp.id;
|
|
break;
|
|
}
|
|
}
|
|
if (last_value == null)
|
|
last_value = _settings_hub.current.ladder;
|
|
}
|
|
settings_subject.OnNext(last_value);
|
|
}
|
|
}
|
|
|
|
void open_settings_dialog() {
|
|
// dialog vm
|
|
var dialog_vm = new ProfiledShellSettingsDialogVM<LadderSettings, LadderSettingsVM, LadderSettingsProfile>(
|
|
profile_service,
|
|
us => us.ladder ?? LadderSettings.Default,
|
|
s => {
|
|
var svm = new LadderSettingsVM(model.order_gateway, vm.security);
|
|
svm.load(s);
|
|
return svm;
|
|
},
|
|
_ => _,
|
|
vm.get_save_state(),
|
|
UserSettings.FileExtensions.LADDER,
|
|
LadderSettings.profile_equals,
|
|
settings_id);
|
|
dialog_vm.applied += apply;
|
|
// dialog
|
|
var dialog = new ShellSettingsDialog { DataContext = dialog_vm };
|
|
dialog_vm.SubscribeDisposed(title_source.OnDispatcher().Subscribe(t => dialog_vm.title = t));
|
|
dialog.Resources[ShellSettingsDialog.SecurityMapKey] = _securities;
|
|
dialog_vm.RequestClose += on_request_close;
|
|
dialog.Closed += on_closed;
|
|
Disposable.replace(ref active_settings_dialog, Disposable.Create(destroy_all));
|
|
dialog.move_to_mouse(-500, -500);
|
|
dialog.Show();
|
|
// local methods
|
|
void apply(SettingsProfile<LadderSettings> profile) {
|
|
settings_id = profile.id;
|
|
last_value = profile.value;
|
|
settings_subject.OnNext(profile.value);
|
|
}
|
|
// idempotent
|
|
void destroy_all() {
|
|
destroy_window();
|
|
destroy_vm();
|
|
}
|
|
// idempotent
|
|
void destroy_window() {
|
|
if (dialog == null) return;
|
|
try {
|
|
var temp = dialog;
|
|
dialog = null;
|
|
temp.Closed -= on_closed;
|
|
temp.Close();
|
|
} catch (Exception ex) {
|
|
on_error("closing window", ex);
|
|
}
|
|
}
|
|
// idempotent
|
|
void destroy_vm() {
|
|
if (dialog_vm == null) return;
|
|
try {
|
|
var temp = dialog_vm;
|
|
dialog_vm = null;
|
|
temp.applied -= apply;
|
|
temp.RequestClose -= on_request_close;
|
|
temp.Dispose();
|
|
} catch (Exception ex) {
|
|
on_error("disposing vm", ex);
|
|
}
|
|
}
|
|
void on_closed(object sender, EventArgs e) => destroy_all();
|
|
void on_request_close(object sender, EventArgs e) => destroy_all();
|
|
void on_error(string action_desc, Exception error) =>
|
|
Log.Ui.warn($"LadderSettingsDialog error {action_desc}: {error}.");
|
|
}
|
|
});
|
|
return shell_window = ShellWindow.create(
|
|
module, md.security.ToString(), _window_type, view,
|
|
(v, s) => save(_get_state(((LadderView)v).vm, settings_id), s),
|
|
icon: Icons.Ladder,
|
|
thread_id: _thread_id_provider.next_id(),
|
|
swvm => {
|
|
shell_window_vm = swvm;
|
|
title_source.connect();
|
|
},
|
|
key_event_args => vm?.key_down(key_event_args));
|
|
}
|
|
|
|
async void _show_windows(IImmutableSet<uint> securities) {
|
|
if (securities == null)
|
|
return;
|
|
var start_time = DateTime.Now;
|
|
do {
|
|
var found = securities.KeyJoin(_securities).ToList();
|
|
securities = securities.RemoveRange(found.Select(SecurityMD.key_fn));
|
|
show_windows(found);
|
|
if (securities.Count == 0)
|
|
break;
|
|
await Task.Delay(500);
|
|
} while ((DateTime.Now - start_time) < _ladder_conf.security_timeout);
|
|
}
|
|
|
|
void show_windows(IEnumerable<SecurityMD> securities) {
|
|
int n_allowed = (int)_ladder_conf.max_open_ladders - _wm.list_windows().Where(w => w.window_type == _window_type).Count();
|
|
int n_opened = 0;
|
|
foreach (var s in securities) {
|
|
if (++n_opened > n_allowed) {
|
|
BTSMessageBox.Show($"The maximum number of ladders are already opened ({_ladder_conf.max_open_ladders}).", "Ladders",
|
|
BTSMessageBoxButtons.OK, MessageBoxImage.Exclamation, true, false, true);
|
|
break;
|
|
} else {
|
|
_bus.post(SparkTags.ShowWindow, create_ladder_window(s, null));
|
|
}
|
|
}
|
|
}
|
|
|
|
readonly struct LadderConfig {
|
|
public readonly uint max_open_ladders;
|
|
public readonly bool ladders_on_threads, open_algo_popup_on_select, use_algo_param_grid;
|
|
public readonly TimeSpan security_timeout;
|
|
|
|
public LadderConfig(bts.config.LadderKnobs knobs, bool ladders_on_threads) {
|
|
max_open_ladders = knobs.max_open_ladders;
|
|
open_algo_popup_on_select = knobs.open_algo_popup_on_select;
|
|
use_algo_param_grid = knobs.use_algo_param_grid;
|
|
security_timeout = TimeSpan.FromSeconds(Math.Max(15, knobs.security_timeout_secs));
|
|
this.ladders_on_threads = ladders_on_threads;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ProtoContract]
|
|
class LadderSaveState {
|
|
[ProtoMember(1)]
|
|
public UInt32 security_key;
|
|
[ProtoMember(2)]
|
|
public mbts.spark.LadderSettings settings;
|
|
[ProtoMember(3)]
|
|
public uint settings_id;
|
|
}
|
|
} |