split up OrderTypeDefVMS into there own classes

This commit is contained in:
John Colvin committed 2018-03-06 13:50:02 -05:00
1 parent 58be751faa
commit cf8faf8c4e
14 files changed
+587 -523

No files matched your search

@@ -97,6 +97,6 @@ namespace mbts.spark {
protected override void _on_size_changed(uint? value) => _size_dirty.refresh();
protected override void _on_selected_account_changed(string value) => _account_dirty.refresh();
protected override void _on_selected_time_in_force_changed(TimeInForce value) => _time_in_force_dirty.refresh();
protected override void _on_selected_order_type_changed(IOrderTypeDefVM value) => _order_type_dirty.refresh();
protected override void _on_selected_order_type_changed(IOrderTypeVM value) => _order_type_dirty.refresh();
}
}
-502
View File
@@ -1,502 +0,0 @@
using bts.api;
using bts.api.orderman;
using bts.spark;
using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Input;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark {
interface IOrderTypeDefVM : IPropertyWrapperVM<CustomOrderDefinition, CustomOrderDefinitionImmutable> {
CustomOneofCase order_type { get; }
string type_name { get; }
bool is_bts_type { get; }
OrderMetadata meta { get; }
string display_name { get; }
bool key_match(KeyEventArgs e);
}
// TODO: if such validation specificity is unnecessary, we should probably remove this interface
// as well as the 'is_ready' property from ISecurityOrderTypeDefVM and instead
// rely on INotifyDataErrorInfo's HasErrors property and ErrorsChanged event.
interface IParameterizedOrderTypeDefVM : IOrderTypeDefVM {
event Action<IParameterizedOrderTypeDefVM, bool> parameters_valid_changed;
bool parameters_valid { get; }
}
// TODO: maybe remove is_ready/error_message and instead rely in INotifyDataErrorInfo's HasErrors property and ErrorsChanged event.
// (see above IParameterizedOrderTypeDefVM)
interface ISecurityOrderTypeDefVM : IOrderTypeDefVM {
event Action<ISecurityOrderTypeDefVM, bool, string> is_ready_changed;
bool is_ready { get; }
string error_message { get; }
void set_security(SecurityImmutable security);
}
interface ILazyOrderTypeDefVM : IOrderTypeDefVM {
bool is_initialized { get; }
void initialize();
}
static class OrderTypeDefVMFactory {
public static IOrderTypeDefVM market(OrderFactory factory) => new MarketOrderVM(factory);
public static IOrderTypeDefVM limit(OrderFactory factory) => new LimitOrderVM(factory);
public static IOrderTypeDefVM stop(OrderFactory factory) => new StopOrderVM(factory);
public static IOrderTypeDefVM stop_limit(OrderFactory factory) => new StopLimitOrderVM(factory);
public static IOrderTypeDefVM time_box(OrderFactory factory) => new TimeBoxOrderVM(factory);
public static ISecurityOrderTypeDefVM iceberg(OrdersModel orders_model) => new IcebergOrderVM(orders_model);
public static ISecurityOrderTypeDefVM spreader(OrdersModel orders_model) => new SpreaderOrderVM(orders_model);
public static ObservableAutoWrapper<IOrderTypeDefVM, CustomOneofCase> get_collection(OrdersModel model, ObservableCollection<CustomOneofCase> order_types_model,
Action<ISecurityOrderTypeDefVM, bool, string> on_is_ready_changed, Action<IParameterizedOrderTypeDefVM, bool> on_parameters_valid_changed) {
var order_types = new ObservableAutoWrapper<IOrderTypeDefVM, CustomOneofCase>(order_types_model, _get_factory(model));
foreach (var svm in order_types.OfType<ISecurityOrderTypeDefVM>())
svm.is_ready_changed += on_is_ready_changed;
foreach (var pvm in order_types.OfType<IParameterizedOrderTypeDefVM>())
pvm.parameters_valid_changed += on_parameters_valid_changed;
var on_order_type_created = new Action<IOrderTypeDefVM, CustomOneofCase>((vm, ot) => {
if (vm is ISecurityOrderTypeDefVM svm)
svm.is_ready_changed += on_is_ready_changed;
if (vm is IParameterizedOrderTypeDefVM pvm)
pvm.parameters_valid_changed += on_parameters_valid_changed;
});
order_types.ViewCreated += on_order_type_created;
order_types.ViewDestroyed += vm => {
if (vm is ISecurityOrderTypeDefVM svm)
svm.is_ready_changed -= on_is_ready_changed;
if (vm is IParameterizedOrderTypeDefVM pvm)
pvm.parameters_valid_changed -= on_parameters_valid_changed;
};
return order_types;
}
static Func<CustomOneofCase, IOrderTypeDefVM> _get_factory(OrdersModel orders_model) =>
new Func<CustomOneofCase, IOrderTypeDefVM>(ot => _create(ot, orders_model));
static IOrderTypeDefVM _create(CustomOneofCase order_type, OrdersModel model) {
switch(order_type) {
case CustomOneofCase.Market: return market(model.factory);
case CustomOneofCase.Limit: return limit(model.factory);
case CustomOneofCase.Stop: return stop(model.factory);
case CustomOneofCase.StopLimit: return stop_limit(model.factory);
case CustomOneofCase.TimeBox: return time_box(model.factory);
case CustomOneofCase.Iceberg: return iceberg(model);
case CustomOneofCase.Spreader: return spreader(model);
default: throw new NotImplementedException();
}
}
#region Implentations
private abstract class OrderTypeVMBase : ViewModelBaseWithValidation, IOrderTypeDefVM {
protected readonly OrderFactory factory;
protected OrderTypeVMBase(OrderFactory factory) => this.factory = factory;
public abstract CustomOneofCase order_type { get; }
public abstract string type_name { get; }
public bool is_bts_type => display_name.StartsWith("BTS");
public string display_name => OrderUtils.order_type_display_name(order_type);
public OrderMetadata meta => factory.get_metadata(order_type);
public virtual bool has_editable_properties => !meta.NoProps;
public abstract void assign_to(CustomOrderDefinition value);
public void load_from(CustomOrderDefinitionImmutable value) {
if (value.CustomCase == order_type) load_from_internal(value);
}
public bool key_match(KeyEventArgs key) =>
key.Key == (Key.A + display_name[0] - 'A');
protected virtual void load_from_internal(CustomOrderDefinitionImmutable value) { }
}
private abstract class OrderTypeVMBase<T> : OrderTypeVMBase where T : Google.Protobuf.IMessage, new() {
protected OrderTypeVMBase(OrderFactory factory) : base(factory) { }
public override CustomOneofCase order_type =>
OrderDataHelper.get_order_type(new T());
public override string type_name => new T().Descriptor.Name;
}
private abstract class SecurityOrderTypeVMBase<T> : OrderTypeVMBase<T>, ISecurityOrderTypeDefVM where T : Google.Protobuf.IMessage, new() {
protected SecurityOrderTypeVMBase(OrderFactory factory) : base(factory) { }
public event Action<ISecurityOrderTypeDefVM, bool, string> is_ready_changed;
public bool is_ready => string.IsNullOrEmpty(error_message);
public virtual string error_message => string.Empty;
public abstract void set_security(SecurityImmutable security);
protected IDisposable _defer_invoke_is_ready_changed() {
bool was_ready = is_ready;
return Disposable.Create(() => { if (is_ready != was_ready) is_ready_changed?.Invoke(this, !was_ready, error_message); });
}
protected void _raise_is_ready_changed() =>
is_ready_changed?.Invoke(this, is_ready, error_message);
}
private class MarketOrderVM : OrderTypeVMBase<MarketOrderDefinition> {
internal MarketOrderVM(OrderFactory factory) : base(factory) { }
public override void assign_to(CustomOrderDefinition parent) =>
parent.Market = factory.market_order();
}
private class LimitOrderVM : OrderTypeVMBase<LimitOrderDefinition> {
internal LimitOrderVM(OrderFactory factory) : base(factory) { }
public override void assign_to(CustomOrderDefinition value) =>
value.Limit = factory.limit_order();
}
private class StopOrderVM : SecurityOrderTypeVMBase<StopOrderDefinition>, IParameterizedOrderTypeDefVM {
double _stop_price = double.NaN;
internal StopOrderVM(OrderFactory factory) : base(factory) { }
public event Action<IParameterizedOrderTypeDefVM, bool> parameters_valid_changed;
public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(stop_price);
public double stop_price {
get => _stop_price;
set {
using (_defer_invoke_parameters_valid_changed())
_stop_price = value;
}
}
public ContractSpecificationImmutable spec { get; private set; } =
SecurityDataHelper.Defaults.ContractSpecificationImmutable;
public override void assign_to(CustomOrderDefinition value) {
ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid.");
var s = factory.stop_order();
s.StopPrice = stop_price;
value.Stop = s;
}
public override void set_security(SecurityImmutable security) {
spec = security.ContractSpec;
RaisePropertyChanged(nameof(spec));
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_parameters_valid_changed()) {
stop_price = value.Stop.StopPrice;
RaisePropertyChanged(nameof(stop_price));
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
private class StopLimitOrderVM : SecurityOrderTypeVMBase<StopLimitOrderDefinition>, IParameterizedOrderTypeDefVM {
double _stop_price = double.NaN;
internal StopLimitOrderVM(OrderFactory factory) : base(factory) { }
public event Action<IParameterizedOrderTypeDefVM, bool> parameters_valid_changed;
public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(_stop_price);
public double stop_price {
get => _stop_price;
set {
using (_defer_invoke_parameters_valid_changed())
_stop_price = value;
}
}
public ContractSpecificationImmutable spec { get; private set; } =
SecurityDataHelper.Defaults.ContractSpecificationImmutable;
public override void assign_to(CustomOrderDefinition value) {
ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid.");
var sl = factory.stop_limit_order();
sl.StopPrice = stop_price;
value.StopLimit = sl;
}
public override void set_security(SecurityImmutable security) {
spec = security.ContractSpec;
RaisePropertyChanged(nameof(spec));
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_parameters_valid_changed()) {
stop_price = value.StopLimit.StopPrice;
RaisePropertyChanged(nameof(stop_price));
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
private class IcebergOrderVM : SecurityOrderTypeVMBase<IcebergOrderDefinition>, IParameterizedOrderTypeDefVM, ILazyOrderTypeDefVM {
readonly OrdersModel _orders_model;
readonly ObservableCollection<CustomOneofCase> _child_order_types_model =
new ObservableCollection<CustomOneofCase>(EnumHelper.get_values_except(CustomOneofCase.None));
ObservableAutoWrapper<IOrderTypeDefVM, CustomOneofCase> _child_order_types;
SecurityImmutable? _security;
IOrderTypeDefVM _child_order;
double _show_quantity = double.NaN;
internal IcebergOrderVM(OrdersModel orders_model) : base(orders_model.factory) =>
_orders_model = orders_model;
public event Action<IParameterizedOrderTypeDefVM, bool> parameters_valid_changed;
public bool parameters_valid {
get {
if (DoubleHelper.IsNaNOrInfinityOr(_show_quantity, 0)) return false;
if (_child_order == null) return false;
if (_child_order is IParameterizedOrderTypeDefVM pvm) return pvm.parameters_valid;
return child_order_types.Contains(_child_order);
}
}
public override string error_message {
get {
if (child_order == null) return "no child order selected";
else if (child_order is IParameterizedOrderTypeDefVM pvm && !pvm.parameters_valid) return "child parameters invalid";
return (child_order as ISecurityOrderTypeDefVM)?.error_message ?? string.Empty;
}
}
public bool is_initialized => _child_order_types != null;
public IOrderTypeDefVM child_order {
get => _child_order;
set {
using (_defer_invoke_is_ready_changed()) {
if (!is_initialized) initialize();
if ((value is ILazyOrderTypeDefVM lvm) && !lvm.is_initialized) lvm.initialize();
_child_order = value;
RaisePropertyChanged();
}
}
}
public ObservableCollection<IOrderTypeDefVM> child_order_types {
get {
if (!is_initialized) initialize();
return _child_order_types;
}
}
public double show_quantity {
get => _show_quantity;
set {
using (_defer_invoke_parameters_valid_changed())
_show_quantity = value;
}
}
public override void assign_to(CustomOrderDefinition value) {
var i = factory.iceberg_order();
i.ShowQuantity = show_quantity;
child_order.assign_to(i.Child);
value.Iceberg = i;
}
public override void set_security(SecurityImmutable security) {
using (_defer_invoke_is_ready_changed()) {
_security = security;
_child_order_types_model.sync_with(factory.default_order_types(security));
if (_child_order_types != null) {
foreach (var ot in _child_order_types.OfType<ISecurityOrderTypeDefVM>())
ot.set_security(_security.Value);
_select_child_order_if_invalid();
}
}
}
public void initialize() {
if (_child_order_types == null) {
_child_order_types = get_collection(_orders_model, _child_order_types_model, _on_child_order_is_ready_changed, _on_child_order_parameters_valid_changed);
foreach (var ot in _child_order_types.OfType<ISecurityOrderTypeDefVM>())
ot.set_security(_security.Value);
_select_child_order_if_invalid();
}
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_is_ready_changed())
using (_defer_invoke_parameters_valid_changed()) {
show_quantity = value.Iceberg.ShowQuantity;
child_order = _child_order_types.FirstOrDefault(ot => ot.order_type == value.CustomCase);
RaisePropertyChanged(nameof(show_quantity), nameof(child_order));
}
}
void _select_child_order_if_invalid() {
if (_child_order_types.Count > 0 && (child_order == null || !_child_order_types.Contains(child_order))) {
var ot = _orders_model.factory.default_order_type(_security, true);
var child = _child_order_types.FirstOrDefault(vm => vm.order_type == CustomOneofCase.Limit);
// do not select an ILazyOrderTypeDefVM child by default, this will cause a stack overflow
if (child == null || child is ILazyOrderTypeDefVM)
child = _child_order_types.FirstOrDefault(vm => !(vm is ILazyOrderTypeDefVM));
if (child != null) {
child_order = child;
RaisePropertyChanged(nameof(child_order));
}
}
}
void _validate_selected_order_type() {
using (validation(nameof(child_order))) {
var svm = _child_order as ISecurityOrderTypeDefVM;
var pvm = _child_order as IParameterizedOrderTypeDefVM;
validation_assert(
_child_order != null && _child_order_types.Contains(_child_order) && (svm == null || svm.is_ready),
svm?.error_message ?? string.Empty, nameof(child_order)
);
}
}
void _on_child_order_is_ready_changed(ISecurityOrderTypeDefVM sender, bool is_ready, string error_message) {
if (sender == _child_order) {
_validate_selected_order_type();
_raise_is_ready_changed();
}
}
void _on_child_order_parameters_valid_changed(IParameterizedOrderTypeDefVM sender, bool parameters_valid) {
if (sender == _child_order) {
using (_defer_invoke_parameters_valid_changed())
_validate_selected_order_type();
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
private class TimeBoxOrderVM : OrderTypeVMBase<TimeBoxOrderDefinition>, IParameterizedOrderTypeDefVM {
TimeTextTuple _start = TimeTextTuple.FromDateTime(DateTime.Now), _stop = TimeTextTuple.FromDateTime(DateTime.Now.AddMinutes(5));
internal TimeBoxOrderVM(OrderFactory factory) : base(factory) { }
public event Action<IParameterizedOrderTypeDefVM, bool> parameters_valid_changed;
public bool parameters_valid => _start.result.HasValue && _stop.result.HasValue;
public TimeTextTuple start {
get => _start;
set {
using (_defer_invoke_parameters_valid_changed())
using (validation(nameof(start)))
validation_assert((_start = value).result.HasValue, string.Empty, nameof(start));
}
}
public TimeTextTuple stop {
get => _stop;
set {
using (_defer_invoke_parameters_valid_changed())
using (validation(nameof(stop)))
validation_assert((_stop = value).result.HasValue, string.Empty, nameof(stop));
}
}
public override void assign_to(CustomOrderDefinition value) {
DateTime? start_result = start.result, stop_result = stop.result;
ExceptionAssert.InvalidOperation.That(start_result.HasValue && stop_result.HasValue, "TimeBoxOrderVm parameters are invalid.");
var tb = factory.time_box_order();
tb.Start = start.result.Value.ToUniversalTime().ToGoogleTime();
tb.Stop = stop.result.Value.ToUniversalTime().ToGoogleTime();
value.TimeBox = tb;
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_parameters_valid_changed()) {
start = TimeTextTuple.FromDateTime(value.TimeBox.Start.ToDateTime().ToLocalTime());
stop = TimeTextTuple.FromDateTime(value.TimeBox.Stop.ToDateTime().ToLocalTime());
RaisePropertyChanged(nameof(start), nameof(stop));
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
private class SpreaderOrderVM : SecurityOrderTypeVMBase<SpreaderOrderDefinition> {
SecurityImmutable? _security;
OrdersModel _orders_model;
ExecutionStrategyImmutable? _strategy;
SyntheticEditorVM _strategy_editor;
internal SpreaderOrderVM(OrdersModel orders_model) : base(orders_model.factory) =>
_orders_model = orders_model;
public SyntheticEditorVM strategy_editor {
get {
if (_strategy_editor == null && _security.HasValue && _strategy.HasValue)
_strategy_editor = new SyntheticEditorVM(_orders_model.spreader, _security.Value, _strategy.Value);
return _strategy_editor;
}
}
public override bool has_editable_properties =>
base.has_editable_properties && _security.HasValue && _strategy.HasValue;
public override string error_message =>
_security.HasValue && _strategy.HasValue ? string.Empty : "waiting for strategy";
public override async void set_security(SecurityImmutable security) {
using (_defer_invoke_is_ready_changed()) {
_security = security;
var lookup = await _orders_model.spreader.lookup_strategy_async(security);
if (lookup.success) _strategy = lookup.result;
RaisePropertyChanged(nameof(has_editable_properties));
}
}
public override void assign_to(CustomOrderDefinition value) {
if (is_ready) {
var s = factory.spreader_order();
s.ExecutionStrategy = (_strategy_editor != null ? _strategy_editor.create_strategy() : _strategy.Value).CloneToMutable();
s.Security = _security.Value.CloneToMutable();
value.Spreader = s;
}
}
// this strategy will be overwritten by strategy changes to any synthetic (due to subscription in constructor)
protected override void load_from_internal(CustomOrderDefinitionImmutable value) =>
_strategy = value.Spreader.ExecutionStrategy;
}
#endregion
}
}
@@ -27,7 +27,7 @@ namespace mbts.ui.spark {
public DataTemplate ReflectionTemplate { get; set; }
public override DataTemplate SelectTemplate(object item, DependencyObject container) {
var vm = item as IOrderTypeDefVM;
var vm = item as IOrderTypeVM;
if (vm != null) {
switch (vm.order_type) {
case CustomOrderDefinition.CustomOneofCase.Stop: return StopMarketOrderTemplate;
@@ -35,7 +35,7 @@ namespace mbts.spark {
double _price = double.NaN;
string _selected_account;
TimeInForce _selected_time_in_force = TimeInForce.Undefined;
IOrderTypeDefVM _selected_order_type;
IOrderTypeVM _selected_order_type;
protected OrderPropertiesEditorVM(OrdersModel model, IObservable<SecurityImmutable> security_source, IObservable<LadderSettings> settings)
: this(model, security_source, settings.Select(s => new InlineOrderProperties(
@@ -47,7 +47,7 @@ namespace mbts.spark {
protected OrderPropertiesEditorVM(OrdersModel model, IObservable<SecurityImmutable> security_source, IObservable<InlineOrderProperties> order_properties, IObservable<int[]> calcuator_buttons) {
_model = model;
accounts = model.factory.accounts;
order_types = OrderTypeDefVMFactory.get_collection(model, _order_types_model, _on_order_type_is_ready_changed, _on_parameters_valid_changed);
order_types = OrderTypeVMFactory.get_collection(model, _order_types_model, _on_order_type_is_ready_changed, _on_parameters_valid_changed);
set_price_command = new DelegateCommand<double>(p => {
price = p;
RaisePropertyChanged(nameof(price));
@@ -60,12 +60,12 @@ namespace mbts.spark {
using (detect_property_changes()) {
security = s;
_order_types_model.sync_with(model.factory.default_order_types(security));
foreach (var vm in order_types.OfType<ISecurityOrderTypeDefVM>())
foreach (var vm in order_types.OfType<ISecurityOrderTypeVM>())
vm.set_security(s);
security_changed?.Invoke(s);
if (props.order_type_def.has_value) {
if (props.order_type_def.force_override || selected_order_type == null || !order_types.Contains(selected_order_type)) {
if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeDefVM match)) {
if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeVM match)) {
match.load_from(props.order_type_def.value);
selected_order_type = match;
}
@@ -105,7 +105,7 @@ namespace mbts.spark {
}
if (props.order_type_def.has_value) {
if (props.order_type_def.force_override || selected_order_type == null || !order_types.Contains(selected_order_type)) {
if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeDefVM match)) {
if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeVM match)) {
match.load_from(props.order_type_def.value);
selected_order_type = match;
}
@@ -125,8 +125,8 @@ namespace mbts.spark {
public string selected_account { get => _selected_account; set => _on_selected_account_changed(_selected_account = value); }
public ObservableCollection<TimeInForce> time_in_forces { get; } = new ObservableCollection<TimeInForce>();
public TimeInForce selected_time_in_force { get => _selected_time_in_force; set { _on_selected_time_in_force_changed(_selected_time_in_force = value); _validate_selected_time_in_force(); } }
public ObservableAutoWrapper<IOrderTypeDefVM, CustomOrderDefinition.CustomOneofCase> order_types { get; }
public IOrderTypeDefVM selected_order_type {
public ObservableAutoWrapper<IOrderTypeVM, CustomOrderDefinition.CustomOneofCase> order_types { get; }
public IOrderTypeVM selected_order_type {
get => _selected_order_type;
set {
if ((value is ILazyOrderTypeDefVM lvm) && !lvm.is_initialized)
@@ -161,7 +161,7 @@ namespace mbts.spark {
protected virtual void _on_size_changed(uint? value) { }
protected virtual void _on_selected_account_changed(string value) { }
protected virtual void _on_selected_time_in_force_changed(TimeInForce value) { }
protected virtual void _on_selected_order_type_changed(IOrderTypeDefVM value) { }
protected virtual void _on_selected_order_type_changed(IOrderTypeVM value) { }
protected void _validate_selected_account() {
using (validation(nameof(selected_account)))
@@ -175,8 +175,8 @@ namespace mbts.spark {
protected void _validate_selected_order_type() {
using (validation(nameof(selected_order_type))) {
var svm = _selected_order_type as ISecurityOrderTypeDefVM;
var pvm = _selected_order_type as IParameterizedOrderTypeDefVM;
var svm = _selected_order_type as ISecurityOrderTypeVM;
var pvm = _selected_order_type as IParameterizedOrderTypeVM;
validation_assert(
_selected_order_type != null &&
order_types.Contains(_selected_order_type) &&
@@ -187,12 +187,12 @@ namespace mbts.spark {
}
}
void _on_order_type_is_ready_changed(ISecurityOrderTypeDefVM sender, bool is_ready, string error_message) {
void _on_order_type_is_ready_changed(ISecurityOrderTypeVM sender, bool is_ready, string error_message) {
if (sender == _selected_order_type)
_validate_selected_order_type();
}
void _on_parameters_valid_changed(IParameterizedOrderTypeDefVM sender, bool parameters_valid) {
void _on_parameters_valid_changed(IParameterizedOrderTypeVM sender, bool parameters_valid) {
if (sender == _selected_order_type)
_validate_selected_order_type();
}
@@ -0,0 +1,39 @@
using bts.api;
using bts.api.orderman;
using bts.spark;
using System;
using System.Windows.Input;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark {
interface IOrderTypeVM : IPropertyWrapperVM<CustomOrderDefinition, CustomOrderDefinitionImmutable> {
CustomOneofCase order_type { get; }
string type_name { get; }
bool is_bts_type { get; }
OrderMetadata meta { get; }
string display_name { get; }
bool key_match(KeyEventArgs e);
}
// TODO: if such validation specificity is unnecessary, we should probably remove this interface
// as well as the 'is_ready' property from ISecurityOrderTypeDefVM and instead
// rely on INotifyDataErrorInfo's HasErrors property and ErrorsChanged event.
interface IParameterizedOrderTypeVM : IOrderTypeVM {
event Action<IParameterizedOrderTypeVM, bool> parameters_valid_changed;
bool parameters_valid { get; }
}
// TODO: maybe remove is_ready/error_message and instead rely in INotifyDataErrorInfo's HasErrors property and ErrorsChanged event.
// (see above IParameterizedOrderTypeDefVM)
interface ISecurityOrderTypeVM : IOrderTypeVM {
event Action<ISecurityOrderTypeVM, bool, string> is_ready_changed;
bool is_ready { get; }
string error_message { get; }
void set_security(SecurityImmutable security);
}
interface ILazyOrderTypeDefVM : IOrderTypeVM {
bool is_initialized { get; }
void initialize();
}
}
@@ -0,0 +1,157 @@
using bts.api;
using bts.api.orderman;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class IcebergOrderVM : SecurityOrderTypeVMBase<IcebergOrderDefinition>, IParameterizedOrderTypeVM, ILazyOrderTypeDefVM {
readonly OrdersModel _orders_model;
readonly ObservableCollection<CustomOneofCase> _child_order_types_model =
new ObservableCollection<CustomOneofCase>(EnumHelper.get_values_except(CustomOneofCase.None));
ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_types;
SecurityImmutable? _security;
IOrderTypeVM _child_order;
double _show_quantity = double.NaN;
internal IcebergOrderVM(OrdersModel orders_model) : base(orders_model.factory) =>
_orders_model = orders_model;
public event Action<IParameterizedOrderTypeVM, bool> parameters_valid_changed;
public bool parameters_valid {
get {
if (DoubleHelper.IsNaNOrInfinityOr(_show_quantity, 0)) return false;
if (_child_order == null) return false;
if (_child_order is IParameterizedOrderTypeVM pvm) return pvm.parameters_valid;
return child_order_types.Contains(_child_order);
}
}
public override string error_message {
get {
if (child_order == null) return "no child order selected";
else if (child_order is IParameterizedOrderTypeVM pvm && !pvm.parameters_valid) return "child parameters invalid";
return (child_order as ISecurityOrderTypeVM)?.error_message ?? string.Empty;
}
}
public bool is_initialized => _child_order_types != null;
public IOrderTypeVM child_order {
get => _child_order;
set {
using (_defer_invoke_is_ready_changed()) {
if (!is_initialized) initialize();
if ((value is ILazyOrderTypeDefVM lvm) && !lvm.is_initialized) lvm.initialize();
_child_order = value;
RaisePropertyChanged();
}
}
}
public ObservableCollection<IOrderTypeVM> child_order_types {
get {
if (!is_initialized) initialize();
return _child_order_types;
}
}
public double show_quantity {
get => _show_quantity;
set {
using (_defer_invoke_parameters_valid_changed())
_show_quantity = value;
}
}
public override void assign_to(CustomOrderDefinition value) {
var i = factory.iceberg_order();
i.ShowQuantity = show_quantity;
child_order.assign_to(i.Child);
value.Iceberg = i;
}
public override void set_security(SecurityImmutable security) {
using (_defer_invoke_is_ready_changed()) {
_security = security;
_child_order_types_model.sync_with(factory.default_order_types(security));
if (_child_order_types != null) {
foreach (var ot in _child_order_types.OfType<ISecurityOrderTypeVM>())
ot.set_security(_security.Value);
_select_child_order_if_invalid();
}
}
}
public void initialize() {
if (_child_order_types == null) {
_child_order_types = get_collection(_orders_model, _child_order_types_model, _on_child_order_is_ready_changed, _on_child_order_parameters_valid_changed);
foreach (var ot in _child_order_types.OfType<ISecurityOrderTypeVM>())
ot.set_security(_security.Value);
_select_child_order_if_invalid();
}
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_is_ready_changed())
using (_defer_invoke_parameters_valid_changed()) {
show_quantity = value.Iceberg.ShowQuantity;
child_order = _child_order_types.FirstOrDefault(ot => ot.order_type == value.CustomCase);
RaisePropertyChanged(nameof(show_quantity), nameof(child_order));
}
}
void _select_child_order_if_invalid() {
if (_child_order_types.Count > 0 && (child_order == null || !_child_order_types.Contains(child_order))) {
var ot = _orders_model.factory.default_order_type(_security, true);
var child = _child_order_types.FirstOrDefault(vm => vm.order_type == CustomOneofCase.Limit);
// do not select an ILazyOrderTypeDefVM child by default, this will cause a stack overflow
if (child == null || child is ILazyOrderTypeDefVM)
child = _child_order_types.FirstOrDefault(vm => !(vm is ILazyOrderTypeDefVM));
if (child != null) {
child_order = child;
RaisePropertyChanged(nameof(child_order));
}
}
}
void _validate_selected_order_type() {
using (validation(nameof(child_order))) {
var svm = _child_order as ISecurityOrderTypeVM;
var pvm = _child_order as IParameterizedOrderTypeVM;
validation_assert(
_child_order != null && _child_order_types.Contains(_child_order) && (svm == null || svm.is_ready),
svm?.error_message ?? string.Empty, nameof(child_order)
);
}
}
void _on_child_order_is_ready_changed(ISecurityOrderTypeVM sender, bool is_ready, string error_message) {
if (sender == _child_order) {
_validate_selected_order_type();
_raise_is_ready_changed();
}
}
void _on_child_order_parameters_valid_changed(IParameterizedOrderTypeVM sender, bool parameters_valid) {
if (sender == _child_order) {
using (_defer_invoke_parameters_valid_changed())
_validate_selected_order_type();
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
}
}
@@ -0,0 +1,13 @@
using bts.api.orderman;
using mbts.spark.utilities;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class LimitOrderVM : OrderTypeVMBase<LimitOrderDefinition> {
internal LimitOrderVM(OrderFactory factory) : base(factory) { }
public override void assign_to(CustomOrderDefinition value) =>
value.Limit = factory.limit_order();
}
}
}
@@ -0,0 +1,13 @@
using bts.api.orderman;
using mbts.spark.utilities;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class MarketOrderVM : OrderTypeVMBase<MarketOrderDefinition> {
internal MarketOrderVM(OrderFactory factory) : base(factory) { }
public override void assign_to(CustomOrderDefinition parent) =>
parent.Market = factory.market_order();
}
}
}
@@ -0,0 +1,116 @@
using bts.api;
using bts.api.orderman;
using bts.spark;
using mbts.spark.utilities;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Input;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
public static IOrderTypeVM market(OrderFactory factory) => new MarketOrderVM(factory);
public static IOrderTypeVM limit(OrderFactory factory) => new LimitOrderVM(factory);
public static IOrderTypeVM stop(OrderFactory factory) => new StopOrderVM(factory);
public static IOrderTypeVM stop_limit(OrderFactory factory) => new StopLimitOrderVM(factory);
public static IOrderTypeVM time_box(OrderFactory factory) => new TimeBoxOrderVM(factory);
public static ISecurityOrderTypeVM iceberg(OrdersModel orders_model) => new IcebergOrderVM(orders_model);
public static ISecurityOrderTypeVM spreader(OrdersModel orders_model) => new SpreaderOrderVM(orders_model);
public static ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> get_collection(OrdersModel model, ObservableCollection<CustomOneofCase> order_types_model,
Action<ISecurityOrderTypeVM, bool, string> on_is_ready_changed, Action<IParameterizedOrderTypeVM, bool> on_parameters_valid_changed) {
var order_types = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(order_types_model, _get_factory(model));
foreach (var svm in order_types.OfType<ISecurityOrderTypeVM>())
svm.is_ready_changed += on_is_ready_changed;
foreach (var pvm in order_types.OfType<IParameterizedOrderTypeVM>())
pvm.parameters_valid_changed += on_parameters_valid_changed;
var on_order_type_created = new Action<IOrderTypeVM, CustomOneofCase>((vm, ot) => {
if (vm is ISecurityOrderTypeVM svm)
svm.is_ready_changed += on_is_ready_changed;
if (vm is IParameterizedOrderTypeVM pvm)
pvm.parameters_valid_changed += on_parameters_valid_changed;
});
order_types.ViewCreated += on_order_type_created;
order_types.ViewDestroyed += vm => {
if (vm is ISecurityOrderTypeVM svm)
svm.is_ready_changed -= on_is_ready_changed;
if (vm is IParameterizedOrderTypeVM pvm)
pvm.parameters_valid_changed -= on_parameters_valid_changed;
};
return order_types;
}
static Func<CustomOneofCase, IOrderTypeVM> _get_factory(OrdersModel orders_model) =>
new Func<CustomOneofCase, IOrderTypeVM>(ot => _create(ot, orders_model));
static IOrderTypeVM _create(CustomOneofCase order_type, OrdersModel model) {
switch (order_type) {
case CustomOneofCase.Market: return market(model.factory);
case CustomOneofCase.Limit: return limit(model.factory);
case CustomOneofCase.Stop: return stop(model.factory);
case CustomOneofCase.StopLimit: return stop_limit(model.factory);
case CustomOneofCase.TimeBox: return time_box(model.factory);
case CustomOneofCase.Iceberg: return iceberg(model);
case CustomOneofCase.Spreader: return spreader(model);
default: throw new NotImplementedException();
}
}
#region OrderTypeVM Base Classes
private abstract class OrderTypeVMBase : ViewModelBaseWithValidation, IOrderTypeVM {
protected readonly OrderFactory factory;
protected OrderTypeVMBase(OrderFactory factory) => this.factory = factory;
public abstract CustomOneofCase order_type { get; }
public abstract string type_name { get; }
public bool is_bts_type => display_name.StartsWith("BTS");
public string display_name => OrderUtils.order_type_display_name(order_type);
public OrderMetadata meta => factory.get_metadata(order_type);
public virtual bool has_editable_properties => !meta.NoProps;
public abstract void assign_to(CustomOrderDefinition value);
public void load_from(CustomOrderDefinitionImmutable value) {
if (value.CustomCase == order_type) load_from_internal(value);
}
public bool key_match(KeyEventArgs key) =>
key.Key == (Key.A + display_name[0] - 'A');
protected virtual void load_from_internal(CustomOrderDefinitionImmutable value) { }
}
private abstract class OrderTypeVMBase<T> : OrderTypeVMBase where T : Google.Protobuf.IMessage, new() {
protected OrderTypeVMBase(OrderFactory factory) : base(factory) { }
public override CustomOneofCase order_type =>
OrderDataHelper.get_order_type(new T());
public override string type_name => new T().Descriptor.Name;
}
private abstract class SecurityOrderTypeVMBase<T> : OrderTypeVMBase<T>, ISecurityOrderTypeVM where T : Google.Protobuf.IMessage, new() {
protected SecurityOrderTypeVMBase(OrderFactory factory) : base(factory) { }
public event Action<ISecurityOrderTypeVM, bool, string> is_ready_changed;
public bool is_ready => string.IsNullOrEmpty(error_message);
public virtual string error_message => string.Empty;
public abstract void set_security(SecurityImmutable security);
protected IDisposable _defer_invoke_is_ready_changed() {
bool was_ready = is_ready;
return Disposable.Create(() => { if (is_ready != was_ready) is_ready_changed?.Invoke(this, !was_ready, error_message); });
}
protected void _raise_is_ready_changed() =>
is_ready_changed?.Invoke(this, is_ready, error_message);
}
#endregion
}
}
@@ -0,0 +1,53 @@
using bts.api;
using bts.api.orderman;
using bts.spark;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class SpreaderOrderVM : SecurityOrderTypeVMBase<SpreaderOrderDefinition> {
SecurityImmutable? _security;
OrdersModel _orders_model;
ExecutionStrategyImmutable? _strategy;
SyntheticEditorVM _strategy_editor;
internal SpreaderOrderVM(OrdersModel orders_model) : base(orders_model.factory) =>
_orders_model = orders_model;
public SyntheticEditorVM strategy_editor {
get {
if (_strategy_editor == null && _security.HasValue && _strategy.HasValue)
_strategy_editor = new SyntheticEditorVM(_orders_model.spreader, _security.Value, _strategy.Value);
return _strategy_editor;
}
}
public override bool has_editable_properties =>
base.has_editable_properties && _security.HasValue && _strategy.HasValue;
public override string error_message =>
_security.HasValue && _strategy.HasValue ? string.Empty : "waiting for strategy";
public override async void set_security(SecurityImmutable security) {
using (_defer_invoke_is_ready_changed()) {
_security = security;
var lookup = await _orders_model.spreader.lookup_strategy_async(security);
if (lookup.success) _strategy = lookup.result;
RaisePropertyChanged(nameof(has_editable_properties));
}
}
public override void assign_to(CustomOrderDefinition value) {
if (is_ready) {
var s = factory.spreader_order();
s.ExecutionStrategy = (_strategy_editor != null ? _strategy_editor.create_strategy() : _strategy.Value).CloneToMutable();
s.Security = _security.Value.CloneToMutable();
value.Spreader = s;
}
}
// this strategy will be overwritten by strategy changes to any synthetic (due to subscription in constructor)
protected override void load_from_internal(CustomOrderDefinitionImmutable value) =>
_strategy = value.Spreader.ExecutionStrategy;
}
}
}
@@ -0,0 +1,57 @@
using bts.api;
using bts.api.orderman;
using mbts.spark.utilities;
using mbts.utils;
using System;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class StopLimitOrderVM : SecurityOrderTypeVMBase<StopLimitOrderDefinition>, IParameterizedOrderTypeVM {
double _stop_price = double.NaN;
internal StopLimitOrderVM(OrderFactory factory) : base(factory) { }
public event Action<IParameterizedOrderTypeVM, bool> parameters_valid_changed;
public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(_stop_price);
public double stop_price {
get => _stop_price;
set {
using (_defer_invoke_parameters_valid_changed())
_stop_price = value;
}
}
public ContractSpecificationImmutable spec { get; private set; } =
SecurityDataHelper.Defaults.ContractSpecificationImmutable;
public override void assign_to(CustomOrderDefinition value) {
ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid.");
var sl = factory.stop_limit_order();
sl.StopPrice = stop_price;
value.StopLimit = sl;
}
public override void set_security(SecurityImmutable security) {
spec = security.ContractSpec;
RaisePropertyChanged(nameof(spec));
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_parameters_valid_changed()) {
stop_price = value.StopLimit.StopPrice;
RaisePropertyChanged(nameof(stop_price));
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
}
}
@@ -0,0 +1,57 @@
using bts.api;
using bts.api.orderman;
using mbts.spark.utilities;
using mbts.utils;
using System;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class StopOrderVM : SecurityOrderTypeVMBase<StopOrderDefinition>, IParameterizedOrderTypeVM {
double _stop_price = double.NaN;
internal StopOrderVM(OrderFactory factory) : base(factory) { }
public event Action<IParameterizedOrderTypeVM, bool> parameters_valid_changed;
public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(stop_price);
public double stop_price {
get => _stop_price;
set {
using (_defer_invoke_parameters_valid_changed())
_stop_price = value;
}
}
public ContractSpecificationImmutable spec { get; private set; } =
SecurityDataHelper.Defaults.ContractSpecificationImmutable;
public override void assign_to(CustomOrderDefinition value) {
ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid.");
var s = factory.stop_order();
s.StopPrice = stop_price;
value.Stop = s;
}
public override void set_security(SecurityImmutable security) {
spec = security.ContractSpec;
RaisePropertyChanged(nameof(spec));
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_parameters_valid_changed()) {
stop_price = value.Stop.StopPrice;
RaisePropertyChanged(nameof(stop_price));
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
}
}
@@ -0,0 +1,61 @@
using bts.api.orderman;
using mbts.spark.utilities;
using mbts.ui;
using mbts.utils;
using System;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
private class TimeBoxOrderVM : OrderTypeVMBase<TimeBoxOrderDefinition>, IParameterizedOrderTypeVM {
TimeTextTuple _start = TimeTextTuple.FromDateTime(DateTime.Now), _stop = TimeTextTuple.FromDateTime(DateTime.Now.AddMinutes(5));
internal TimeBoxOrderVM(OrderFactory factory) : base(factory) { }
public event Action<IParameterizedOrderTypeVM, bool> parameters_valid_changed;
public bool parameters_valid => _start.result.HasValue && _stop.result.HasValue;
public TimeTextTuple start {
get => _start;
set {
using (_defer_invoke_parameters_valid_changed())
using (validation(nameof(start)))
validation_assert((_start = value).result.HasValue, string.Empty, nameof(start));
}
}
public TimeTextTuple stop {
get => _stop;
set {
using (_defer_invoke_parameters_valid_changed())
using (validation(nameof(stop)))
validation_assert((_stop = value).result.HasValue, string.Empty, nameof(stop));
}
}
public override void assign_to(CustomOrderDefinition value) {
DateTime? start_result = start.result, stop_result = stop.result;
ExceptionAssert.InvalidOperation.That(start_result.HasValue && stop_result.HasValue, "TimeBoxOrderVm parameters are invalid.");
var tb = factory.time_box_order();
tb.Start = start.result.Value.ToUniversalTime().ToGoogleTime();
tb.Stop = stop.result.Value.ToUniversalTime().ToGoogleTime();
value.TimeBox = tb;
}
protected override void load_from_internal(CustomOrderDefinitionImmutable value) {
using (_defer_invoke_parameters_valid_changed()) {
start = TimeTextTuple.FromDateTime(value.TimeBox.Start.ToDateTime().ToLocalTime());
stop = TimeTextTuple.FromDateTime(value.TimeBox.Stop.ToDateTime().ToLocalTime());
RaisePropertyChanged(nameof(start), nameof(stop));
}
}
IDisposable _defer_invoke_parameters_valid_changed() {
bool was_valid = parameters_valid;
return Disposable.Create(() => {
if (parameters_valid != was_valid)
parameters_valid_changed?.Invoke(this, !was_valid);
});
}
}
}
}
@@ -36,16 +36,16 @@ namespace mbts.ui.spark.algo
#endregion
#region ItemsSource
public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register(nameof(ItemsSource), typeof(IEnumerable<IOrderTypeDefVM>), typeof(OrderDetailsPopupControl),
public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register(nameof(ItemsSource), typeof(IEnumerable<IOrderTypeVM>), typeof(OrderDetailsPopupControl),
new PropertyMetadata(null, OnItemsSourceChanged, CoerceItemsSource));
private static object CoerceItemsSource(DependencyObject d, object baseValue) { return baseValue as IEnumerable<IOrderTypeDefVM> ?? Enumerable.Empty<IOrderTypeDefVM>(); }
private static object CoerceItemsSource(DependencyObject d, object baseValue) { return baseValue as IEnumerable<IOrderTypeVM> ?? Enumerable.Empty<IOrderTypeVM>(); }
private static void OnItemsSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
var cvs = CollectionViewSource.GetDefaultView(e.NewValue);
cvs.GroupDescriptions.Add(new PropertyGroupDescription(nameof(IOrderTypeDefVM.is_bts_type)));
cvs.SortDescriptions.Add(new SortDescription(nameof(IOrderTypeDefVM.is_bts_type), ListSortDirection.Ascending));
cvs.GroupDescriptions.Add(new PropertyGroupDescription(nameof(IOrderTypeVM.is_bts_type)));
cvs.SortDescriptions.Add(new SortDescription(nameof(IOrderTypeVM.is_bts_type), ListSortDirection.Ascending));
d.SetValue(ItemsViewPropertyKey, cvs);
}
public IEnumerable<IOrderTypeDefVM> ItemsSource { get => GetValue(ItemsSourceProperty) as IEnumerable<IOrderTypeDefVM>; set => SetValue(ItemsSourceProperty, value); }
public IEnumerable<IOrderTypeVM> ItemsSource { get => GetValue(ItemsSourceProperty) as IEnumerable<IOrderTypeVM>; set => SetValue(ItemsSourceProperty, value); }
#endregion
#region ItemsView (ReadOnly)
@@ -62,10 +62,10 @@ namespace mbts.ui.spark.algo
#endregion
#region SelectedItem
public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register(nameof(SelectedItem), typeof(IOrderTypeDefVM), typeof(OrderDetailsPopupControl),
public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register(nameof(SelectedItem), typeof(IOrderTypeVM), typeof(OrderDetailsPopupControl),
new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
public IOrderTypeDefVM SelectedItem { get => GetValue(SelectedItemProperty) as IOrderTypeDefVM; set => SetValue(SelectedItemProperty, value); }
public IOrderTypeVM SelectedItem { get => GetValue(SelectedItemProperty) as IOrderTypeVM; set => SetValue(SelectedItemProperty, value); }
#endregion
void TrySetGridColumnWidths() {