From 60ea25e7f9803f100973eb9959d48441fe39a90c Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 1 Mar 2018 11:18:42 -0500 Subject: [PATCH] ticket/ladder order type dropdown filters items based on the security --- .../Order/OrderDetailsPopupControl.xaml.cs | 2 +- .../spark/view/Spark/Ladder/LadderVM.cs | 40 ++++-- .../view/Spark/Orders/IOrderTypeDefVM.cs | 103 ++++++++----- .../spark/view/Spark/Orders/OrderTicketVM.cs | 136 +++++++++--------- .../view/Spark/Utilities/OrderDataHelper.cs | 30 +++- src/client/spark/view/Utility/WPFHelper.cs | 22 +++ 6 files changed, 210 insertions(+), 123 deletions(-) diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs index 2bda7e590..b2a6b3fcf 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs @@ -72,7 +72,7 @@ namespace mbts.ui.spark.algo private static void SelectedItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs baseValue) { var item = ((OrderDetailsPopupControl)d).SelectedItem; - d.SetValue(HasEditablePropertiesProperty, !item.meta.NoProps); + d.SetValue(HasEditablePropertiesProperty, item != null && !item.meta.NoProps); } public IOrderTypeDefVM SelectedItem { get => GetValue(SelectedItemProperty) as IOrderTypeDefVM; set => SetValue(SelectedItemProperty, value); } diff --git a/src/client/spark/view/Spark/Ladder/LadderVM.cs b/src/client/spark/view/Spark/Ladder/LadderVM.cs index a7d2f3512..24e185945 100644 --- a/src/client/spark/view/Spark/Ladder/LadderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderVM.cs @@ -4,9 +4,11 @@ using mbts.co2; using mbts.ui; using mbts.ui.controls; using mbts.ui.shell; +using mbts.ui.utility; using System; using System.Collections.Generic; using System.Collections.ObjectModel; +using System.Collections.Specialized; using System.Linq; using System.Reactive.Linq; using System.Threading.Tasks; @@ -53,22 +55,18 @@ namespace mbts.spark { _open = backing(nameof(open), ""); _volume = backing(nameof(volume), 0ul); - _market = OrderTypeDefVMFactory.market(model.order_gateway.factory); - _limit = OrderTypeDefVMFactory.limit(model.order_gateway.factory); - _stop = OrderTypeDefVMFactory.stop(model.order_gateway.factory); - _stop_limit = OrderTypeDefVMFactory.stop_limit(model.order_gateway.factory); - _iceberg = OrderTypeDefVMFactory.iceberg(model.order_gateway.factory, model.order_gateway.spreader); - _iceberg.set_security(model.security); - _time_box = OrderTypeDefVMFactory.time_box(model.order_gateway.factory); - _spreader = OrderTypeDefVMFactory.spreader(model.order_gateway.factory, model.order_gateway.spreader); - _spreader.set_security(model.security); - // calculator calculator = new CalculatorLogic(0, settings.Select(s => s.calculator_buttons)); // Order + order_types = OrderTypeDefVMFactory.get_collection(model.order_gateway, Observable.Return(model.security)); + WPFHelper.select_first_item(order_types, new Action(ot => { + if (!_try_select_settings_algo()) { + selected_order_type = ot; + RaisePropertyChanged(nameof(selected_order_type)); + } + })); _selected_time_in_force = backing(nameof(selected_order_type), TimeInForce.Day); - selected_order_type = _limit; _revert = backing(nameof(revert), false); send_order_command = new AsyncCommand<(double, Side?)>(send_order); cancel_command = new AsyncCommand(_cancel); @@ -78,6 +76,11 @@ namespace mbts.spark { this.settings = settings; _dispose = Disposable.Create( calculator, + Disposable.Create(() => { + foreach (var ot in order_types.OfType()) + ot.Dispose(); + order_types.Dispose(); + }), settings.Subscribe(settings_updated), // need to subscribe to all orders, and cache them, because parent orders don't necessarily have the same security // and OrderVM needs access to parent orders, if there are any @@ -178,8 +181,6 @@ namespace mbts.spark { #endregion #region Orders - readonly IOrderTypeDefVM _market, _limit, _stop, _stop_limit, _time_box; - readonly ISecurityOrderTypeDefVM _iceberg, _spreader; Property _revert; Property _selected_time_in_force; @@ -189,7 +190,7 @@ namespace mbts.spark { public TimeInForce[] time_in_forces => Enum.GetValues(typeof(TimeInForce)).Cast().ToArray(); public TimeInForce selected_time_in_force { get => _selected_time_in_force.Value; set => _selected_time_in_force.Value = value; } - public IOrderTypeDefVM[] order_types => new[] { _market, _limit, _stop, _stop_limit, _iceberg, _time_box, _spreader }; + public IRXCollection order_types { get; } public IOrderTypeDefVM selected_order_type { get; set; } public ObservableCollection orders { get; } = new ObservableCollection(); public IAsyncCommand cancel_command { get; } @@ -272,12 +273,21 @@ namespace mbts.spark { void settings_updated(LadderSettings settings) { if (selected_order_type == null) { - selected_order_type = order_types.FirstOrDefault(o => o.type_name == settings.SelectedAlgo) ?? order_types.First(); selected_time_in_force = (TimeInForce)Enum.Parse(typeof(TimeInForce), settings.DefaultTimeInForce); RaisePropertyChanged(nameof(selected_order_type), nameof(selected_time_in_force)); } if (!calculator.value.HasValue) calculator.value = settings.size; _settings = settings; } + + bool _try_select_settings_algo() { + var algo_match = order_types.FirstOrDefault(o => o.type_name == _settings.SelectedAlgo); + if (algo_match != null) { + selected_order_type = algo_match; + RaisePropertyChanged(nameof(selected_order_type)); + return true; + } + return false; + } } } \ No newline at end of file diff --git a/src/client/spark/view/Spark/Orders/IOrderTypeDefVM.cs b/src/client/spark/view/Spark/Orders/IOrderTypeDefVM.cs index d9cf2c647..349399dc1 100644 --- a/src/client/spark/view/Spark/Orders/IOrderTypeDefVM.cs +++ b/src/client/spark/view/Spark/Orders/IOrderTypeDefVM.cs @@ -1,9 +1,14 @@ using bts.api; using bts.api.orderman; using bts.spark; +using mbts.collections.extensions; using mbts.spark.utilities; +using mbts.ui; using mbts.ui.shell; +using mbts.ui.utility; using System; +using System.Linq; +using System.Reactive.Linq; using System.Windows.Input; namespace mbts.spark { @@ -15,6 +20,7 @@ namespace mbts.spark { string display_name { get; } bool key_match(KeyEventArgs e); } + interface ISecurityOrderTypeDefVM : IOrderTypeDefVM { bool is_ready { get; } void set_security(SecurityImmutable security); @@ -25,9 +31,39 @@ namespace mbts.spark { 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 ISecurityOrderTypeDefVM iceberg(OrderFactory factory, SpreaderModel model) => new IcebergOrderVM(factory, model); public static IOrderTypeDefVM time_box(OrderFactory factory) => new TimeBoxOrderVM(factory); - public static ISecurityOrderTypeDefVM spreader(OrderFactory factory, SpreaderModel spreader_model) => new SpreaderOrderVM(factory, spreader_model); + public static ISecurityOrderTypeDefVM iceberg(OrdersModel orders_model) => new IcebergOrderVM(orders_model); + public static ISecurityOrderTypeDefVM spreader(OrdersModel orders_model) => new SpreaderOrderVM(orders_model); + + public static IRXCollection get_collection(OrdersModel orders_model, IObservable security) { + var vm_factory = _vm_factory(orders_model); + return RXCollection.Create(security, (collection, sec) => { + var order_types = orders_model.factory.security_order_types(sec).ToList(); + collection.RemoveWhere(otd => !order_types.Contains(otd.order_type)); + var new_order_types = order_types.Except(collection.Select(otd => otd.order_type)).ToList(); + foreach (var ot in new_order_types) { + var vm = vm_factory(ot); + if (vm != null) { + (vm as ISecurityOrderTypeDefVM)?.set_security(sec); + collection.Add(vm); + } + } + }); + } + + static Func _vm_factory(OrdersModel orders_model) => + new Func(order_type => { + switch (order_type) { + case CustomOrderDefinition.CustomOneofCase.Market: return market(orders_model.factory); + case CustomOrderDefinition.CustomOneofCase.Limit: return limit(orders_model.factory); + case CustomOrderDefinition.CustomOneofCase.Stop: return stop(orders_model.factory); + case CustomOrderDefinition.CustomOneofCase.StopLimit: return stop_limit(orders_model.factory); + case CustomOrderDefinition.CustomOneofCase.TimeBox: return time_box(orders_model.factory); + case CustomOrderDefinition.CustomOneofCase.Iceberg: return iceberg(orders_model); + case CustomOrderDefinition.CustomOneofCase.Spreader: return spreader(orders_model); + default: return null; + } + }); #region Implentations private abstract class OrderTypeVMBase : ViewModelBase, IOrderTypeDefVM { @@ -114,29 +150,30 @@ namespace mbts.spark { } } - private class IcebergOrderVM : OrderTypeVMBase, ISecurityOrderTypeDefVM { - readonly IOrderTypeDefVM _market, _limit, _stop, _stop_limit, _time_box, _spreader; - readonly Lazy _iceberg; + private class IcebergOrderVM : OrderTypeVMBase, ISecurityOrderTypeDefVM, IDisposable { + readonly OrdersModel _orders_model; + IRXCollection _order_types; SecurityImmutable? _security; - internal IcebergOrderVM(OrderFactory factory, SpreaderModel spreader_model) : base(factory) { - _market = market(factory); - _limit = limit(factory); - _stop = stop(factory); - _stop_limit = stop_limit(factory); - _iceberg = new Lazy(() => { - var ovm = iceberg(factory, spreader_model); - if (_security.HasValue) - ovm.set_security(_security.Value); - return ovm; - }); - _time_box = time_box(factory); - _spreader = spreader(factory, spreader_model); - child_order = _limit; - } + internal IcebergOrderVM(OrdersModel orders_model) : base(orders_model.factory) => + _orders_model = orders_model; + + event Action _on_security; public double show_quantity { get; set; } - public IOrderTypeDefVM[] child_order_types => new[] { _market, _limit, _stop, _stop_limit, _iceberg.Value, _time_box, _spreader }; + public IRXCollection child_order_types { + get { + if (_order_types == null) { + var sec_src = Observable.FromEvent(cb => _on_security += cb, cb => _on_security -= cb); + _order_types = get_collection(_orders_model, _security.HasValue ? sec_src.StartWith(_security.Value) : sec_src); + WPFHelper.select_first_item(_order_types, new Action(ot => { + child_order = ot; + RaisePropertyChanged(nameof(child_order)); + })); + } + return _order_types; + } + } public IOrderTypeDefVM child_order { get; set; } public bool is_ready { get { @@ -160,9 +197,14 @@ namespace mbts.spark { public void set_security(SecurityImmutable security) { _security = security; - ((ISecurityOrderTypeDefVM)_spreader).set_security(security); - if (_iceberg.IsValueCreated) - ((ISecurityOrderTypeDefVM)_iceberg.Value).set_security(security); + _on_security?.Invoke(security); + } + + public void Dispose() { + if (_order_types != null) { + foreach (var ot in _order_types.OfType()) ot.Dispose(); + _order_types.Dispose(); + } } } @@ -186,20 +228,19 @@ namespace mbts.spark { } } - private class SpreaderOrderVM : OrderTypeVMBase, ISecurityOrderTypeDefVM, IDisposable { + private class SpreaderOrderVM : OrderTypeVMBase, ISecurityOrderTypeDefVM { SecurityImmutable? _security; - SpreaderModel _model; - IDisposable _strategy_sub; + OrdersModel _orders_model; ExecutionStrategyImmutable? _strategy; - internal SpreaderOrderVM(OrderFactory factory, SpreaderModel spreader_model) : base(factory) => - _model = spreader_model; + internal SpreaderOrderVM(OrdersModel orders_model) : base(orders_model.factory) => + _orders_model = orders_model; public bool is_ready => _security.HasValue && _strategy.HasValue; public async void set_security(SecurityImmutable security) { _security = security; - var lookup = await _model.lookup_strategy_async(security); + var lookup = await _orders_model.spreader.lookup_strategy_async(security); if (lookup.success) _strategy = lookup.result; } @@ -216,8 +257,6 @@ namespace mbts.spark { // 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; - - public void Dispose() => Disposable.dispose(ref _strategy_sub); } #endregion } diff --git a/src/client/spark/view/Spark/Orders/OrderTicketVM.cs b/src/client/spark/view/Spark/Orders/OrderTicketVM.cs index 8ac3d5a9e..3386ad745 100644 --- a/src/client/spark/view/Spark/Orders/OrderTicketVM.cs +++ b/src/client/spark/view/Spark/Orders/OrderTicketVM.cs @@ -10,10 +10,8 @@ using System.Linq; using System.Reactive.Linq; using System.Windows.Input; -namespace mbts.spark -{ +namespace mbts.spark { class OrderTicketVM : DisposableViewModelBase, IRequestViewClose { - readonly IOrderTypeDefVM _market, _limit, _stop, _stop_limit, _time_box, _spreader, _iceberg; OrderDefinitionImmutable _def = OrderDataHelper.Defaults.OrderDefinitionImmutable; uint _key; @@ -26,74 +24,68 @@ namespace mbts.spark .Select(tup => new OrderParams(tup.security.Value, tup.order.Def, order_key, wprice:tup.order.State.Price, wsize:tup.order.working_quantity())), settings) { } OrderTicketVM(OrdersModel model, IObservable order_params, IObservable settings) { - _market = OrderTypeDefVMFactory.market(model.factory); - _limit = OrderTypeDefVMFactory.limit(model.factory); - _stop = OrderTypeDefVMFactory.stop(model.factory); - _stop_limit = OrderTypeDefVMFactory.stop_limit(model.factory); - _iceberg = OrderTypeDefVMFactory.iceberg(model.factory, model.spreader); - _time_box = OrderTypeDefVMFactory.time_box(model.factory); - _spreader = OrderTypeDefVMFactory.spreader(model.factory, model.spreader); accounts = model.factory.accounts; bbo = new BBOVM(order_params.Select(o => o.smd)); size_calculator = new CalculatorLogic(null, settings.Select(s => s.calculator_buttons)); set_price_command = new DelegateCommand(p => { price = p; RaisePropertyChanged(nameof(price)); }); send_order = new DelegateCommand(side => { - switch (_input_validity()) { - case InputValidity.Price: size_calculator.flash_value_error(); break; - case InputValidity.Size: flash_error(nameof(price)).ignore(); break; - case InputValidity.Both: - var mo = _def.CloneToMutable(); - mo.Side = side; - selected_order_type.assign_to(mo.CustomDef); - model.send_order(new OrderDefinitionImmutable(mo), price, size_calculator.value.Value).ignore(); - _raise_request_close(); - break; - case InputValidity.None: - size_calculator.flash_value_error(); - flash_error(nameof(price)).ignore(); - break; + var vi = _validate_input(); + if (vi.order_type_valid && vi.price_valid && vi.size_valid) { + var mo = _def.CloneToMutable(); + mo.Side = side; + selected_order_type.assign_to(mo.CustomDef); + model.send_order(new OrderDefinitionImmutable(mo), price, size_calculator.value.Value).ignore(); + _raise_request_close(); } }); modify_order = new DelegateCommand(() => { - switch (_input_validity()) { - case InputValidity.Price: model.update_order_price(_key, price).ignore(); break; - case InputValidity.Size: model.update_order_size(_key, size_calculator.value.Value).ignore(); break; - case InputValidity.Both: model.update_order(_key, price, size_calculator.value.Value).ignore(); break; - case InputValidity.None: - default: - flash_error(nameof(price)).ignore(); - size_calculator.flash_value_error(); - return; + var vi = _validate_input(); + if (vi.order_type_valid) { + if (vi.price_valid) { + if (vi.size_valid) { + model.update_order(_key, price, size_calculator.value.Value).ignore(); + } else { + model.update_order_price(_key, price).ignore(); + } + } else if (vi.size_valid) { + model.update_order_size(_key, size_calculator.value.Value).ignore(); + } else return; + _raise_request_close(); } - _raise_request_close(); }); cancel_order = new DelegateCommand(() => { model.cancel_order(_key).ignore(); _raise_request_close(); }); - _dispose = Disposable.Create(order_params.ObserveOnDispatcher().Subscribe(ops => { - _def = ops.def; - _key = ops.key; - security = ops.smd.security; - foreach (var sec_order in order_types.OfType()) - sec_order.set_security(security); - if (ops.price.HasValue) price = ops.price.Value; - working_price = ops.wprice; - if (ops.size.HasValue) size_calculator.value = ops.size.Value; - working_size = ops.wsize; - account = ops.def.Account; - foreach (var ot in order_types) ot.load_from(_def.CustomDef); - switch (_def.CustomDef.CustomCase) { - case CustomOrderDefinition.CustomOneofCase.Market: selected_order_type = _market; break; - case CustomOrderDefinition.CustomOneofCase.Limit: selected_order_type = _limit; break; - case CustomOrderDefinition.CustomOneofCase.Stop: selected_order_type = _stop; break; - case CustomOrderDefinition.CustomOneofCase.StopLimit: selected_order_type = _stop_limit; break; - case CustomOrderDefinition.CustomOneofCase.Iceberg: selected_order_type = _iceberg; break; - case CustomOrderDefinition.CustomOneofCase.TimeBox: selected_order_type = _time_box; break; - default: selected_order_type = _limit; break; - } - RaisePropertyChanged(nameof(security), nameof(price), nameof(working_price), nameof(working_size), nameof(account), nameof(selected_order_type), nameof(selected_time_in_force)); - }), bbo); + order_types = OrderTypeDefVMFactory.get_collection(model, order_params.Select(ops => ops.smd.security)); + WPFHelper.select_first_item(order_types, new Action(ot => { + selected_order_type = ot; + RaisePropertyChanged(nameof(selected_order_type)); + })); + _dispose = Disposable.Create(bbo, + Disposable.Create(() => { + foreach (var ot in order_types.OfType()) + ot.Dispose(); + order_types.Dispose(); + }), + order_params.ObserveOnDispatcher().Subscribe(ops => { + _def = ops.def; + _key = ops.key; + security = ops.smd.security; + if (ops.price.HasValue) price = ops.price.Value; + working_price = ops.wprice; + if (ops.size.HasValue) size_calculator.value = ops.size.Value; + working_size = ops.wsize; + account = ops.def.Account; + foreach (var ot in order_types) + ot.load_from(_def.CustomDef); + var ot_match = order_types.FirstOrDefault(ot => ot.order_type == _def.CustomDef.CustomCase); + if (ot_match != null) { + selected_order_type = ot_match; + RaisePropertyChanged(nameof(selected_order_type)); + } + RaisePropertyChanged(nameof(security), nameof(price), nameof(working_price), nameof(working_size), nameof(account), nameof(selected_time_in_force)); + })); } public event EventHandler RequestClose; @@ -114,17 +106,20 @@ namespace mbts.spark public ICommand send_order { get; } public ICommand modify_order { get; } public ICommand cancel_order { get; } - public IOrderTypeDefVM[] order_types => new[] { _market, _limit, _stop, _stop_limit, _iceberg, _time_box, _spreader }; + public IRXCollection order_types { get; } public IOrderTypeDefVM selected_order_type { get; set; } - InputValidity _input_validity() => - _order_type_valid() ? - _price_valid() ? - _size_valid() ? - InputValidity.Both : InputValidity.Price : - _size_valid() ? - InputValidity.Size : InputValidity.None : - InputValidity.None; + (bool order_type_valid, bool price_valid, bool size_valid) _validate_input() { + (bool order_type_valid, bool price_valid, bool size_valid) rv = + (_order_type_valid(), _price_valid(), _size_valid()); + if (!rv.order_type_valid) + flash_error(nameof(selected_order_type)).ignore(); + if (!rv.price_valid) + flash_error(nameof(price)).ignore(); + if (!rv.size_valid) + size_calculator.flash_value_error(); + return rv; + } bool _price_valid() => !double.IsNaN(price) && price != 0; @@ -133,9 +128,12 @@ namespace mbts.spark size_calculator.value.HasValue && size_calculator.value.Value != 0; bool _order_type_valid() { - var sec_order = selected_order_type as ISecurityOrderTypeDefVM; - if (sec_order == null) return true; - return sec_order.is_ready; + if (selected_order_type == null) return false; + else { + var sec_order = selected_order_type as ISecurityOrderTypeDefVM; + if (sec_order == null) return true; + return sec_order.is_ready; + } } void _raise_request_close() => diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index 30b20e18b..244afe35d 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -15,8 +15,20 @@ namespace mbts.spark.utilities // OrdersModel imports and exposes OrderFactory as a public property [Export(typeof(OrderFactory))] class OrderFactory { + static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.pinkalicious }; + static readonly CustomOrderDefinition.CustomOneofCase[] + _standard_types = new[] { + CustomOrderDefinition.CustomOneofCase.Market, + CustomOrderDefinition.CustomOneofCase.Limit, + CustomOrderDefinition.CustomOneofCase.Stop, + CustomOrderDefinition.CustomOneofCase.StopLimit, + CustomOrderDefinition.CustomOneofCase.Iceberg, + CustomOrderDefinition.CustomOneofCase.TimeBox, + }, _spreader_types = new[] { + CustomOrderDefinition.CustomOneofCase.Iceberg, + CustomOrderDefinition.CustomOneofCase.Spreader + }; readonly string _login; - static OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.pinkalicious }; [ImportingConstructor] public OrderFactory([Import("username")]string login) { @@ -32,18 +44,24 @@ namespace mbts.spark.utilities Account = accounts[0], SecurityKey = security.Id, Side = Side.Buy, - TimeInForce = bts.api.orderman.TimeInForce.Day, + TimeInForce = TimeInForce.Day, CustomDef = custom_order(), - CtiCode = bts.api.orderman.CTICode.CtiCode1, - CustomerOrFirm = bts.api.orderman.CustomerOrFirm.Firm, + CtiCode = CTICode.CtiCode1, + CustomerOrFirm = CustomerOrFirm.Firm, // this will be the tag 50 on CME orders // current user might be okay, but we might also want to get it // from the store that serves the risk admin gui - ManualOrderIndicator = bts.api.orderman.ManualOrderIndicator.Yes + ManualOrderIndicator = ManualOrderIndicator.Yes }; - public CustomOrderDefinition custom_order() => new CustomOrderDefinition { Limit = limit_order() }; + public IEnumerable security_order_types(SecurityImmutable security) { + switch(security.ContractCase) { + case Security.ContractOneofCase.Synthetic: return _spreader_types; + default: return _standard_types; + } + } + public CustomOrderDefinition custom_order() => new CustomOrderDefinition { Limit = limit_order() }; public MarketOrderDefinition market_order() => new MarketOrderDefinition { }; public LimitOrderDefinition limit_order() => new LimitOrderDefinition { }; public StopOrderDefinition stop_order() => new StopOrderDefinition { }; diff --git a/src/client/spark/view/Utility/WPFHelper.cs b/src/client/spark/view/Utility/WPFHelper.cs index 62d8c7bb9..a01a0785e 100644 --- a/src/client/spark/view/Utility/WPFHelper.cs +++ b/src/client/spark/view/Utility/WPFHelper.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.Collections.Specialized; using System.Linq; using System.Windows; @@ -27,6 +28,27 @@ namespace mbts.ui { } } + public static void select_first_item(TSource source, Action set_selected_item) where TSource : IList, INotifyCollectionChanged => + select_first_item(source, new Func(item => { + set_selected_item(item); + return true; + })); + + public static void select_first_item(TSource source, Func set_selected_item) where TSource : IList, INotifyCollectionChanged { + foreach (var item in source) + if (set_selected_item(item)) return; + NotifyCollectionChangedEventHandler source_changed = null; + source.CollectionChanged += source_changed = (s, e) => { + switch (e.Action) { + case NotifyCollectionChangedAction.Add: + foreach (T item in source) + if (set_selected_item(item)) + source.CollectionChanged -= source_changed; + break; + } + }; + } + public static RowDefinition get_element_row(Grid grid, FrameworkElement element) { int index = Grid.GetRow(element); var rows = grid.RowDefinitions;