SPARK-1446 Try to add securities to security DB even if they already have an assigned security key

We were asserting that completed orders must have non zero fills, but
its easy for an algo to break that so we handle it.

.gitignore

@@ -21,3 +21,5 @@ src/client/sparkcmd/Properties/launchSettings.json
 node_modules
 paket-files
 project.lock.json
+src/server/sparkd/orderman/perf_analysis/data
+src/server/sparkd/orderman/perf_analysis/trace_data/

src/client/Directory.Build.Targets

@@ -39,6 +39,7 @@
 
     <Message Importance="High" Text="Generating service %(Proto3.FileName)" />
     <Exec Command="
+       set PATH=$(spark_build_python_path);%path% &amp;
        set PYTHONPATH=$(Externals)\python &amp;
        $(protoc) ^
        %(Proto3.FullPath) ^

src/client/spark/Daemons/AboutDaemon.cs

@@ -25,7 +25,7 @@ namespace bts.ui {
       public AboutDaemon(IBus bus, [Import("username")]string username, IBrowserWindowManager browser) {
          _user = username;
          _browser = browser;
-         _dispose = bus.subscribe(SparkTags.About).ObserveOnDispatcher().Subscribe(_ => show_about());
+         _dispose = bus.subscribe(SparkTags.About).OnDispatcher().Subscribe(_ => show_about());
       }
 
       [Conditional("DEBUG")]

src/client/spark/Daemons/DeleteSyntheticDaemon.cs

@@ -18,7 +18,7 @@ namespace bts {
       public DeleteSyntheticDaemon(IBus bus, OrdersModel orders_model) {
          _orders_model = orders_model;
          _dispose = bus.subscribe(SparkTags.SyntheticDeleteTag)
-            .ObserveOnDispatcher()
+            .OnDispatcher()
             .Subscribe(_delete_synthetic);
       }
 

src/client/spark/Daemons/ErrorReporter.cs

@@ -7,7 +7,7 @@ using mbts.ui;
 using System;
 using System.ComponentModel.Composition;
 using System.Reactive.Linq;
-using System.Threading.Tasks;
+using System.Windows.Threading;
 using System.Windows;
 
 namespace bts.spark
@@ -22,18 +22,21 @@ namespace bts.spark
       public ErrorReporter(ErrorReportService svc, IBus bus, [Import("username")] string username) {
          _svc = svc;
          _username = username;
-         _dispose = bus.subscribe(SparkTags.Support).ObserveOnDispatcher().Subscribe(msg => show_support_window(msg, "Report a problem"));
+         _dispose = bus.subscribe(SparkTags.Support).OnDispatcher().Subscribe(msg => show_support_window(msg, "Report a problem"));
       }
 
       public void Dispose() {
          Disposable.dispose(ref _dispose);
       }
 
-      public async Task report_error(string message, string title = null, MessageBoxImage? image = null) {
-         var result = await BTSMessageBox.ShowAsync(message, title = "Error", BTSMessageBoxButtons.OK | BTSMessageBoxButtons.Support, image ?? MessageBoxImage.Error);
-         if (result == BTSMessageBoxButtons.Support) {
-            show_support_window(message, title);
-         }
+      public void report_error(string message, string title = null, MessageBoxImage? image = null) {
+         // Error reports are likely to arrive the api thread (which is not an STA thread)
+         Application.Current.Dispatcher.BeginInvoke(async () => {
+            var result = await BTSMessageBox.ShowAsync(message, title = "Error", BTSMessageBoxButtons.OK | BTSMessageBoxButtons.Support, image ?? MessageBoxImage.Error);
+            if (result == BTSMessageBoxButtons.Support) {
+               show_support_window(message, title);
+            }
+         });
       }
 
       public void show_support_window(string message, string title) {
@@ -70,11 +73,11 @@ namespace bts.spark
                return (get_successful_rv(result.value), string.Empty);
             else {
                string error_msg = template.fmt(error);
-               error_reporter.report_error(error_msg).ignore();
+               error_reporter.report_error(error_msg);
                return (get_unsuccessful_rv(), error_msg);
             }
          } else {
-            error_reporter.report_error(result.error_message).ignore();
+            error_reporter.report_error(result.error_message);
             return (get_unsuccessful_rv(), result.error_message);
          }
       }

src/client/spark/Daemons/OrderTicketDaemon.cs

@@ -28,11 +28,11 @@ namespace bts.shell {
          _model = model;
          _error_reporter = error_reporter;
          _dispose = Disposable.Create(
-            model.on_orders.ObserveOnDispatcher().Subscribe(o => _orders = o),
-            bus.subscribe(SparkTags.SecuritiesTag).ObserveOnDispatcher().Subscribe(m =>_md_map = m),
-            bus.subscribe(SparkTags.ShowOrderTicketFromSecurityTag).ObserveOnDispatcher().Subscribe(_show_order_ticket),
-            bus.subscribe(SparkTags.ShowOrderTicketTag).ObserveOnDispatcher().Subscribe(_show_order_ticket),
-            bus.subscribe(SparkTags.ShowModifyOrderTag).ObserveOnDispatcher().Subscribe(_show_modify_order)
+            model.on_orders.OnDispatcher().Subscribe(o => _orders = o),
+            bus.subscribe(SparkTags.SecuritiesTag).OnDispatcher().Subscribe(m =>_md_map = m),
+            bus.subscribe(SparkTags.ShowOrderTicketFromSecurityTag).OnDispatcher().Subscribe(_show_order_ticket),
+            bus.subscribe(SparkTags.ShowOrderTicketTag).OnDispatcher().Subscribe(_show_order_ticket),
+            bus.subscribe(SparkTags.ShowModifyOrderTag).OnDispatcher().Subscribe(_show_modify_order)
          );
       }
 

src/client/spark/Daemons/SecurityPickerDaemon.cs

@@ -23,10 +23,10 @@ namespace bts {
       public SecurityPickerDaemon(IBus bus) {
          _bus = bus;
          _dispose = Disposable.Create(
-            bus.subscribe(SparkTags.ShowPickOne).ObserveOnDispatcher().Subscribe(show_pick_one),
-            bus.subscribe(SparkTags.FilterPickOne).ObserveOnDispatcher().Subscribe(show_filtered_pick_one),
-            bus.subscribe(SparkTags.ShowPickMultiple).ObserveOnDispatcher().Subscribe(show_pick_multiple),
-            bus.subscribe(SparkTags.ShowAndEditPickMultiple).ObserveOnDispatcher().Subscribe(show_and_edit_pick_multiple)
+            bus.subscribe(SparkTags.ShowPickOne).OnDispatcher().Subscribe(show_pick_one),
+            bus.subscribe(SparkTags.FilterPickOne).OnDispatcher().Subscribe(show_filtered_pick_one),
+            bus.subscribe(SparkTags.ShowPickMultiple).OnDispatcher().Subscribe(show_pick_multiple),
+            bus.subscribe(SparkTags.ShowAndEditPickMultiple).OnDispatcher().Subscribe(show_and_edit_pick_multiple)
          );
       }
 

src/client/spark/Modules/Market/MarketView/MarketViewRow.cs

@@ -78,11 +78,11 @@ namespace mbts.spark {
             _animation.AnimationsChanged += on_animations_changed;
             void on_animations_changed() => RaisePropertyChanged(nameof(animations));
             _dispose = Disposable.Create(
-               _orders_model.on_security_orders(security.Id).ObserveOnDispatcher().Subscribe(_on_orders),
-               _position.ObserveOnDispatcher().Subscribe(v => _animation.animate_position(v.newval > v.oldval)),
-               _inside_bids.ObserveOnDispatcher().Subscribe(v => _animation.animate_working_bids_inside(v.newval)),
-               _inside_asks.ObserveOnDispatcher().Subscribe(v => _animation.animate_working_asks_inside(v.newval)),
-               _day_change.ObserveOnDispatcher().Subscribe(v => _animation.animate_day_change(v.newval > v.oldval)),
+               _orders_model.on_security_orders(security.Id).OnDispatcher().Subscribe(_on_orders),
+               _position.OnDispatcher().Subscribe(v => _animation.animate_position(v.newval > v.oldval)),
+               _inside_bids.OnDispatcher().Subscribe(v => _animation.animate_working_bids_inside(v.newval)),
+               _inside_asks.OnDispatcher().Subscribe(v => _animation.animate_working_asks_inside(v.newval)),
+               _day_change.OnDispatcher().Subscribe(v => _animation.animate_day_change(v.newval > v.oldval)),
                Disposable.Create(() => _animation.AnimationsChanged -= on_animations_changed)
             );
          }

src/client/spark/Modules/Market/MarketView/MarketViewVM.cs

@@ -81,7 +81,7 @@ namespace mbts.spark {
          }
          //
          _resources.AddRange(
-            state.ObserveOnDispatcher().Subscribe(s => {
+            state.OnDispatcher().Subscribe(s => {
                using (rows_view.DeferRefresh()) {
                   rows_view.SetSortingCriteria(s.sorting_criteria);
                   var filters = s.filters;

src/client/spark/Modules/Market/MarketView/MarketViewWindow.cs

@@ -57,7 +57,7 @@ namespace mbts.spark {
             SparkCommands.ShowTimeAndSales.complete(_vm.selected_securities_observable(), _ => true, secs => secs.Count > 0 ? new SecurityCriteria(secs) : _state.security_criteria),
             SparkCommands.ShowSyntheticCreate.complete(_vm.selected_securities_observable(), secs => secs.Count > 0 && secs.Count < 3, secs => new SecurityCriteria(secs))
          };
-         _subscriptions = _bus.subscribe(update_securities_tag).ObserveOnDispatcher().Subscribe(c =>
+         _subscriptions = _bus.subscribe(update_securities_tag).OnDispatcher().Subscribe(c =>
             _state_changed?.Invoke(_state = new MarketViewWindowFactory.StartupData(c, _vm.rows_view.GetSortingCriteria(), _vm.get_filter_states())));
       }
 

src/client/spark/Modules/Market/MarketView/MarketViewWindowFactory.cs

@@ -16,7 +16,7 @@ namespace bts.shell {
       public MarketViewWindowFactory(MarketShellModule module, IBus bus, OrdersModel orders_model) : base(module, "MarketView") {
          _bus = bus;
          _orders_model = orders_model;
-         _dispose = bus.subscribe(SparkTags.ShowMarketViewTag).ObserveOnDispatcher().Subscribe(_show);
+         _dispose = bus.subscribe(SparkTags.ShowMarketViewTag).OnDispatcher().Subscribe(_show);
       }
 
       public override Task<IShellWindow> load(StartupData state) =>

src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesWindow.cs

@@ -47,8 +47,8 @@ namespace mbts.spark {
          _vm = new SingleValuePump<TimeAndSalesVM>();
          var update_securities_tag = new SparkTags.SparkTag<SecurityCriteria>("TimeAndSales Callback");
          var update_securities_cmd = SparkCommand.create("Update Time and Sales", Icon, update_securities_tag);
-         var current_smd_source = _vm.observable.SelectMany(vm => vm.current_security_md_observable(_bus)).ObserveOnDispatcher();
-         var selected_secs_source = _vm.observable.SelectMany(vm => vm.selected_securities_observable()).ObserveOnDispatcher();
+         var current_smd_source = _vm.observable.SelectMany(vm => vm.current_security_md_observable(_bus)).OnDispatcher();
+         var selected_secs_source = _vm.observable.SelectMany(vm => vm.selected_securities_observable()).OnDispatcher();
          _commands = new SparkCommand[] {
             SparkCommand.create("Change Securities", Icons.Admin, SparkTags.ShowAndEditPickMultiple, () => (update_securities_cmd, _state.security_criteria)),
             SparkCommands.ShowLadder.complete(current_smd_source, md => md.HasValue, ObjectHelper.ValueOrDefault),
@@ -56,7 +56,7 @@ namespace mbts.spark {
             SparkCommands.ShowFills.complete(selected_secs_source, always_true, get_fills_startup_data),
             SparkCommands.ShowMarketView.complete(selected_secs_source, always_true, secs => secs.Count > 0 ? new SecurityCriteria(secs) : _state.security_criteria)
          };
-         _subscriptions = _bus.subscribe(update_securities_tag).ObserveOnDispatcher().Subscribe(update_criteria);
+         _subscriptions = _bus.subscribe(update_securities_tag).OnDispatcher().Subscribe(update_criteria);
          _initialize();
 
          bool always_true<T>(T _) => true;

src/client/spark/Modules/Market/TimeAndSalesWindowFactory.cs

@@ -23,7 +23,7 @@ namespace bts.shell {
 
          _dispose = Disposable.Create(
             bus.subscribe(SparkTags.SecuritiesTag).Subscribe(s => _securities = s),
-            bus.subscribe(SparkTags.ShowTimeAndSalesTag).ObserveOnDispatcher().Subscribe(show)
+            bus.subscribe(SparkTags.ShowTimeAndSalesTag).OnDispatcher().Subscribe(show)
          );
       }
 

src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml

@@ -15,34 +15,33 @@
     <ResourceDictionary Source="/view/Controls/Popup/PopupControl.xaml"/>
     <ResourceDictionary Source="/Modules/Spreader/ParameterSectionView.xaml"/>
   </ResourceDictionary.MergedDictionaries>
-  <sys:Double x:Key="GroupLevelIndent">18</sys:Double>
   <sys:Double x:Key="RowHeaderWidth">285</sys:Double>
   <sys:Double x:Key="RowHeight">16</sys:Double>
   <sys:Double x:Key="NegativeRowHeight">-16</sys:Double>
   <sys:Double x:Key="ItemsHostCanBeDisabledCollapsedHeight">15</sys:Double>
   <Thickness
     x:Key="GroupLevelMargin"
-    Left="{StaticResource GroupLevelIndent}"
+    Left="{x:Static usp:ExecutionStrategyEditor.GroupLevelIndent}"
   />
   <Thickness
     x:Key="GroupContentAlignedWithHeaderMargin"
-    Left="{StaticResource GroupLevelIndent}"
+    Left="{x:Static usp:ExecutionStrategyEditor.GroupLevelIndent}"
     Top="{StaticResource NegativeRowHeight}"
   />
   <cv:SyntheticPriceCalcDisplayTextConverter x:Key="SyntheticPriceCalcDisplayConverter"/>
   <cv:TickFactorsTextConverter x:Key="TickFactorsTextConverter"/>
   <usp:RowHeaderGroupIndentConverter
     x:Key="RowHeaderGroupIndentConverter"
-    Indent="{StaticResource GroupLevelIndent}"
+    Indent="{x:Static usp:ExecutionStrategyEditor.GroupLevelIndent}"
   />
   <usp:RowHeaderGroupIndentConverter
     x:Key="ReverseRowHeaderGroupIndentConverter"
-    Indent="{StaticResource GroupLevelIndent}"
+    Indent="{x:Static usp:ExecutionStrategyEditor.GroupLevelIndent}"
     Reverse="True"
   />
   <usp:RowGroupExpanderWidthConverter
     x:Key="RowGroupExpanderWidthConverter"
-    Indent="{StaticResource GroupLevelIndent}"
+    Indent="{x:Static usp:ExecutionStrategyEditor.GroupLevelIndent}"
     Offset="{StaticResource RowHeight}"
     RowHeaderWidth="{StaticResource RowHeaderWidth}"
   />
@@ -293,7 +292,7 @@
       </DataTrigger>
     </Style.Triggers>
   </Style>
-  <DataGridTextColumn x:Key="AddColumnPlaceholder" x:Shared="False" IsReadOnly="True">
+  <DataGridTextColumn x:Key="{x:Static usp:ExecutionStrategyEditor.AddColumnPlaceholderKey}" x:Shared="False" IsReadOnly="True">
     <DataGridTextColumn.Header>
       <c:PopupControl
         ShowExpanderArrow="False" PopupPlacement="Right" Header="Add Leg" Padding="6,0"
@@ -308,7 +307,7 @@
       </c:PopupControl>
     </DataGridTextColumn.Header>
   </DataGridTextColumn>
-  <DataTemplate x:Key="RemovableColumnHeaderTemplate">
+  <DataTemplate x:Key="{x:Static usp:ExecutionStrategyEditor.RemovableColumnHeaderTemplateKey}">
     <Grid>
       <Grid.ColumnDefinitions>
         <ColumnDefinition Width="Auto"/>
@@ -321,7 +320,9 @@
       <TextBlock Grid.Column="1" Margin="4,0,0,0" Text="{Binding Converter={StaticResource SecurityTextConverter}}"/>
     </Grid>
   </DataTemplate>
-
+  <DataTemplate x:Key="{x:Static usp:ExecutionStrategyEditor.NonRemovableColumnHeaderTemplateKey}">
+    <TextBlock Text="{Binding Converter={StaticResource SecurityTextConverter}}"/>
+  </DataTemplate>
   <ControlTemplate x:Key="ExecutionStrategyEditorTemplate" TargetType="usp:ExecutionStrategyEditor">
     <Border
       BorderBrush="{TemplateBinding BorderBrush}"

src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml.cs

@@ -25,7 +25,13 @@ namespace mbts.ui.spark {
    /// <summary>
    /// Interaction logic for ExecutionStrategyEditor.xaml
    /// </summary>
-   partial class ExecutionStrategyEditor : Control { 
+   partial class ExecutionStrategyEditor : Control {
+      public const string
+         RemovableColumnHeaderTemplateKey = "RemovableColumnHeaderTemplate",
+         NonRemovableColumnHeaderTemplateKey = "ReadOnlyColumnHeaderTemplate",
+         AddColumnPlaceholderKey = "AddColumnPlaceholder";
+      public const double GroupLevelIndent = 18;
+
       static ExecutionStrategyEditor() =>
          DefaultStyleKeyProperty.OverrideMetadata(typeof(ExecutionStrategyEditor), new FrameworkPropertyMetadata(typeof(ExecutionStrategyEditor)));
 
@@ -196,7 +202,7 @@ namespace mbts.ui.spark {
          if (dg != null) {
             var legs = LegTuples;
             dg.Columns.SetItems(legs.Select(_column_factory));
-            if (IsNew) dg.Columns.Add((DataGridColumn)FindResource("AddColumnPlaceholder"));
+            if (IsNew) dg.Columns.Add((DataGridColumn)FindResource(AddColumnPlaceholderKey));
             _dg_line_adorner = AdornerHelper.attach_continuously_on_loaded(() => new ExecutionStrategyGridLineAdorner(dg), dg);
             _legs_collection_changed_sub = (legs as INotifyCollectionChanged)?.Subscribe((s, e) => dg.Columns.ReflectChange(legs, _column_factory, e));
          }
@@ -204,7 +210,7 @@ namespace mbts.ui.spark {
 
       DataGridColumn _column_factory(LegSpreaderParamsTuple l) {
          var col = new DataGridColumnInternal(l.leg.Security, ParameterCellTemplateConverter, ParameterCellEditingTemplateConverter) { Width = 75, };
-         if (IsNew) col.HeaderTemplate = (DataTemplate)FindResource("RemovableColumnHeaderTemplate");
+         col.HeaderTemplate = (DataTemplate)FindResource(IsNew ? RemovableColumnHeaderTemplateKey : NonRemovableColumnHeaderTemplateKey);
          DataGridEx.SetRightBorder(col, new DataGridExVerticalLine(false, true, Colors.DarkGray, 1));
          return col;
       }
@@ -240,7 +246,7 @@ namespace mbts.ui.spark {
          FrameworkElement _generate_element(IValueConverter cell_template_converter) {
             var rv = new ContentControl();
             rv.SetBinding(ContentControl.ContentProperty, new Binding());
-            rv.SetBinding(ContentControl.ContentTemplateProperty, new Binding("data_type") { Converter = cell_template_converter });
+            rv.SetBinding(ContentControl.ContentTemplateProperty, new Binding(nameof(ICell.data_type)) { Converter = cell_template_converter });
             return rv;
          }
       }

src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs

@@ -25,7 +25,10 @@ namespace mbts.ui.spark
          void _items_presenter_SizeChanged(object sender, SizeChangedEventArgs e) { InvalidateVisual(); }
 
          protected override void draw_vertical_line(DrawingContext dc, double x, DataGridExVerticalLine line) {
-            if (_items_presenter != null) dc.DrawLine(line.pen.Value, new Point(x - 10, 58), new Point(x - 10, _items_presenter.ActualHeight + 58));
+            x -= GroupLevelIndent;
+            var start = _grid.TranslatePoint(new Point(x, _grid.super_header_height + _col_header_presenter.ActualHeight), this);
+            var stop = _grid.TranslatePoint(new Point(x, _grid.ActualHeight), this);
+            dc.DrawLine(line.pen.Value, start, stop);
          }
       }
    }

src/client/spark/Modules/Spreader/ShowSyntheticEditorHandler.cs

@@ -98,9 +98,9 @@ namespace bts.shell {
       void IInitializable.initialize() {
          Disposable.dispose(ref _dispose);
          _dispose = Disposable.Create(
-            _bus.subscribe(SparkTags.ShowSyntheticCreateTag).ObserveOnDispatcher().Subscribe(_show_synthetic_create),
-            _bus.subscribe(SparkTags.ShowSyntheticStrategyTag).ObserveOnDispatcher().Subscribe(_show_synthetic_strategy),
-            _bus.subscribe(SparkTags.ShowSyntheticCloneTag).ObserveOnDispatcher().Subscribe(_show_synthetic_clone)
+            _bus.subscribe(SparkTags.ShowSyntheticCreateTag).OnDispatcher().Subscribe(_show_synthetic_create),
+            _bus.subscribe(SparkTags.ShowSyntheticStrategyTag).OnDispatcher().Subscribe(_show_synthetic_strategy),
+            _bus.subscribe(SparkTags.ShowSyntheticCloneTag).OnDispatcher().Subscribe(_show_synthetic_clone)
          );
       }
 

src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs

@@ -32,14 +32,14 @@ namespace mbts.spark {
             SparkCommand.create("Add", Icons.AddSynthetic, SparkTags.ShowSyntheticCreateTag).complete(
                () => new SecurityCriteria(), () => true
             ), SparkCommand.create("Remove", Icons.RemoveSynthetic, SparkTags.SyntheticDeleteTag).complete(
-               _vm.observable.SelectMany(vm => vm.current_row_observable),
-               can_row_change, r => r == null ? 0 : r.security_key
+               _vm.observable.SelectMany(vm => vm.current_row_observable.SelectMany(observe_row_mod_params)),
+               can_execute, select_security_id
             ), SparkCommand.create("Change", Icons.ModifySynthetic, SparkTags.ShowSyntheticStrategyTag).complete(
                _vm.observable.SelectMany(vm => vm.current_row_observable),
-               can_row_change, r => r == null ? SecurityDataHelper.Defaults.SecurityImmutable : r.security
+               r => r != null, r => r?.security ?? SecurityDataHelper.Defaults.SecurityImmutable
             ), SparkCommand.create("Clone", Icons.CloneSynthetic, SparkTags.ShowSyntheticCloneTag).complete(
-               _vm.observable.SelectMany(vm => vm.current_row_observable),
-               r => r != null && r.strategy.HasValue, r => r == null ? default : (r.security, r.strategy.Value)
+               _vm.observable.SelectMany(vm => vm.current_row_observable.SelectMany(observe_row_strategy)),
+               rs => rs.HasValue, select_row_strategy_tuple
             ), SparkCommands.ShowLadder.complete(
                _vm.observable.SelectMany(vm => vm.current_security_md), md => md.HasValue, ObjectHelper.ValueOrDefault
             ), SparkCommands.ShowOrders.complete(() => new OrderBookWindowFactory.OrderBookStartupData {
@@ -49,10 +49,19 @@ namespace mbts.spark {
                })
          };
 
-         bool can_row_change(SyntheticManagementDialogVM.Row r) =>
-            r != null && r.n_working_orders == 0;
-      }
+         IObservable<RowModificationParams?> observe_row_mod_params(SyntheticManagementDialogVM.Row r) =>
+            r == null ? Observable.Return(new RowModificationParams?()) :
+            _orders_model.security_has_working_orders(r.security_key).Select(hwo => RowModificationParams.create(r.security, hwo));
 
+         IObservable<RowStrategy?> observe_row_strategy(SyntheticManagementDialogVM.Row r) =>
+            r == null ? Observable.Return(new RowStrategy?()) :
+            _orders_model.spreader.security_strategy(r.security.Id).Select(strategy => RowStrategy.create(r.security, strategy));
+
+         uint select_security_id(RowModificationParams? rmp) => rmp.HasValue ? rmp.Value.security.Id : 0;
+         (SecurityImmutable, ExecutionStrategyImmutable) select_row_strategy_tuple(RowStrategy? rs) => rs.HasValue ? (rs.Value.security, rs.Value.strategy) : default;
+         bool can_execute(RowModificationParams? rmp) => rmp.HasValue && !rmp.Value.has_working_orders;
+      }
+ 
       public void initialize(StartupData state) {
          Logger.notnull(state);
          _state = state;
@@ -71,5 +80,31 @@ namespace mbts.spark {
          Disposable.dispose(ref _vm);
          Commands.OfType<IDisposable>().DisposeAll();
       }
+
+      struct RowModificationParams {
+         public readonly SecurityImmutable security;
+         public readonly bool has_working_orders;
+
+         RowModificationParams(SecurityImmutable security, bool has_working_orders) {
+            this.security = security;
+            this.has_working_orders = has_working_orders;
+         }
+
+         public static RowModificationParams? create(SecurityImmutable security, bool has_working_orders) =>
+            new RowModificationParams(security, has_working_orders);
+      }
+
+      struct RowStrategy {
+         public readonly SecurityImmutable security;
+         public readonly ExecutionStrategyImmutable strategy;
+
+         RowStrategy(SecurityImmutable security, ExecutionStrategyImmutable strategy) {
+            this.security = security;
+            this.strategy = strategy;
+         }
+
+         public static RowStrategy? create(SecurityImmutable security, ExecutionStrategyImmutable strategy) =>
+            new RowStrategy(security, strategy);
+      }
    }
 }

src/client/spark/Modules/Spreader/SyntheticManagementWindowFactory.cs

@@ -16,7 +16,7 @@ namespace bts.shell {
       public SyntheticManagementWindowFactory(SpreaderShellModule module, IBus bus, OrdersModel orders_model) : base(module, "SyntheticManagement") {
          _bus = bus;
          _orders_model = orders_model;
-         _dispose = bus.subscribe(SparkTags.ShowSyntheticManagementTag).ObserveOnDispatcher().Subscribe(show);
+         _dispose = bus.subscribe(SparkTags.ShowSyntheticManagementTag).OnDispatcher().Subscribe(show);
       }
 
       public override Task<IShellWindow> load(StartupData state) =>

src/client/spark/Modules/Spreader/VM/Cell.cs

@@ -10,7 +10,7 @@ namespace mbts.spark {
          readonly Property<bool> _enabled;
 
          protected CellBase(IRowModel model, LegSpreaderParamsTuple leg_tup) =>
-            _enabled = backing(nameof(enabled), model.observe_enabled(leg_tup).ObserveOnDispatcher());
+            _enabled = backing(nameof(enabled), model.observe_enabled(leg_tup).OnDispatcher());
 
          public bool enabled => _enabled.Value;
       }
@@ -24,7 +24,7 @@ namespace mbts.spark {
             : base(model, leg_tup) {
             _model = model;
             _leg_tup = leg_tup;
-            _override_value_sub = model.observe_override_value(leg_tup).ObserveOnDispatcher().Subscribe(v => {
+            _override_value_sub = model.observe_override_value(leg_tup).OnDispatcher().Subscribe(v => {
                value = v;
                RaisePropertyChanged(nameof(value));
             });

src/client/spark/Modules/Spreader/VM/SyntheticEditorVM.cs

@@ -44,10 +44,10 @@ namespace mbts.spark {
          _tick_factors = TickUtils.get_regional_ticks(synthetic.ContractSpec).low_tick;
          title = $"Edit '{synthetic.Synthetic.Name}'";
          icon = Icons.ModifySynthetic;
-         _has_working_orders = backing(nameof(has_working_orders), security_has_working_orders.ObserveOnDispatcher());
+         _has_working_orders = backing(nameof(has_working_orders), security_has_working_orders.OnDispatcher());
          var commit = new ObservantAsyncCommand(commit_async);
-         _resources.Add(security_has_working_orders.Select(v => !v).ObserveOnDispatcher().Subscribe(commit));
-         _resources.Add(_has_working_orders.ObserveOnDispatcher().Subscribe(vals => {
+         _resources.Add(security_has_working_orders.Select(v => !v).OnDispatcher().Subscribe(commit));
+         _resources.Add(_has_working_orders.OnDispatcher().Subscribe(vals => {
             if (vals.newval)
                set_error(nameof(has_working_orders), "Security has working orders");
             else clear_error(nameof(has_working_orders));
@@ -173,7 +173,8 @@ namespace mbts.spark {
                }
                _is_setting_price_mults = false;
             };
-            _can_add_leg = backing(nameof(can_add_leg), leg_tuples.ObserveSelf().Select(_ => leg_count < 2), leg_count < 2);
+            //_can_add_leg = backing(nameof(can_add_leg), leg_tuples.ObserveSelf().Select(_ => leg_count < 2), leg_count < 2);
+            _can_add_leg = backing(nameof(can_add_leg), leg_tuples.ObserveSelf().Select(_ => true), true);
          } else {
             _can_add_leg = backing(nameof(can_add_leg), false);
          }

src/client/spark/Modules/Spreader/VM/SyntheticManagementDialogVM.cs

@@ -66,7 +66,7 @@ namespace mbts.spark {
                .Select(t => (uint)(t.state
                   .Where(kv => kv.Value.is_active())
                   .Count())
-                ).ObserveOnDispatcher());
+                ).OnDispatcher());
             name = security.Synthetic.Name;
             n_legs = security.Synthetic.Legs.Count();
             description = SecurityFormatter.format_contract_legs(security.Synthetic.Legs);

src/client/spark/Modules/Support/ActivityLog/ActivityLogWindow.cs

@@ -38,7 +38,7 @@ namespace bts.shell
       }
 
       public void thread_init() {
-         _dispose = _message_src.ObserveOnDispatcher().Subscribe(_messages.AddLog);
+         _dispose = _message_src.OnDispatcher().Subscribe(_messages.AddLog);
          _content =
             new LogViewer {
                ItemsSource = _messages,

src/client/spark/Modules/Support/SupportShellModule.cs

@@ -23,7 +23,7 @@ namespace bts.shell {
       public HelpShellModule(IBus bus, IBrowserWindowManager browser) {
          _awf = new ActivityWindowFactory(this, bus);
          _dispose = Disposable.Create(
-            bus.subscribe(SparkTags.ShowUri).ObserveOnDispatcher().Subscribe(u => browser.Pages.Add(u))
+            bus.subscribe(SparkTags.ShowUri).OnDispatcher().Subscribe(u => browser.Pages.Add(u))
          );
       }
 

src/client/spark/Modules/Trading/Fills/FillsVM.cs

@@ -24,13 +24,16 @@ namespace mbts.spark {
       public FillsVM(IBus bus, OrdersModel model, StartupData state)
          : this(bus, model, _get_observable(bus, model, state), state.sorting_criteria, state.filters) { }
 
-      FillsVM(IBus bus, OrdersModel model, IObservable<ITableUpdateTransform<FillTuple, string>> fills_source, IReadOnlyCollection<SortingCriteria> sorting_criteria, FilterStates filters)
-         : base(RXCollection.CreateTableUpdate(fills_source), sorting_criteria) {
+      FillsVM(IBus bus, OrdersModel model, IObservable<IIncrementalUpdate<FillTuple, FillTupleKey>> fills_source, IReadOnlyCollection<SortingCriteria> sorting_criteria, FilterStates filters)
+         : base(RXCollection.CreateIncrementalUpdate(fills_source), sorting_criteria) {
          _model = model;
          account_filter = DiscreteValuesFilterVM.Create<Row, string>(_model.factory.subscribe_accounts(), r => r.account, nameof(Row.account));
          user_filter = DiscreteValuesFilterVM.Create<Row, string>(_model.factory.subscribe_users(), r => r.user, nameof(Row.user));
          security_filter = DiscreteValuesFilterVM.Create<Row, SecurityImmutable, SecurityCriteria>(
-            fills_source.with_respect_to(ft => ft.security ?? SecurityDataHelper.Defaults.SecurityImmutable, s => s.Id, ft => ft.key).Select(t => (t.added, t.removed)),
+            fills_source.with_respect_to(
+               ft => ft.security_md.HasValue ? ft.security_md.Value.security : SecurityDataHelper.Defaults.SecurityImmutable,
+               s => s.Id, ft => ft.key
+            ).Select(t => (t.added.Values, t.removed.Values)),
             r => r.security,
             SecurityCriteria.from_securities,
             SecurityCriteria.get_to_securities(bus),
@@ -126,8 +129,8 @@ namespace mbts.spark {
       protected override Row row_factory(FillTuple row_model) => new Row(row_model, _model);
       protected override IEnumerable<SortingCriteria> get_default_sorting() { yield return new SortingCriteria(nameof(Row.fill_time), false); }
 
-      static IObservable<ITableUpdateTransform<FillTuple, string>> _get_observable(IBus bus, OrdersModel model, StartupData state) {
-         if (state.orders != null && state.orders.Length == 0) {
+      static IObservable<IIncrementalUpdate<FillTuple, FillTupleKey>> _get_observable(IBus bus, OrdersModel model, StartupData state) {
+         if (!state.orders.is_null_or_empty()) {
             var orders_hash = new HashSet<uint>(state.orders);
             return model.on_fill_tuples.filter(f => orders_hash.Contains(f.fill.OrderKey));
          } else return model.on_fill_tuples;
@@ -138,7 +141,7 @@ namespace mbts.spark {
          readonly FillImmutable _fill;
          readonly OrderRecordImmutable _order;
 
-         public Row(FillTuple fill_tuple, OrdersModel model) : base(fill_tuple.security ?? SecurityDataHelper.Defaults.Security) {
+         public Row(FillTuple fill_tuple, OrdersModel model) : base(fill_tuple.security_md.HasValue ? fill_tuple.security_md.Value.security : SecurityDataHelper.Defaults.Security) {
             _fill = fill_tuple.fill;
             _order = fill_tuple.order ?? OrderDataHelper.Defaults.OrderRecordImmutable;
             _model = model;

src/client/spark/Modules/Trading/Fills/FillsWindowFactory.cs

@@ -18,7 +18,7 @@ namespace bts.shell {
          : base(module, "Fills") {
          _bus = bus;
          _orders_model = orders_model;
-         _dispose = bus.subscribe(SparkTags.ShowFillsTag).ObserveOnDispatcher().Subscribe(show);
+         _dispose = bus.subscribe(SparkTags.ShowFillsTag).OnDispatcher().Subscribe(show);
       }
 
       public override Task<IShellWindow> load(StartupData state) =>

src/client/spark/Modules/Trading/LadderWindowFactory.cs

@@ -30,12 +30,11 @@ namespace bts.shell {
          _wm = wm;
          _settings_hub = settings_hub;
          _orders_model = orders_model;
-         var window_props = Configuration.get<bts.config.IShellWindowProps>();
-         _max_ladders_open = (int)(window_props?.ladder?.max_total_open ?? 75);
+         _max_ladders_open = (int)(Configuration.get<bts.config.LadderKnobs>().max_open_ladders);
          _dispose = Disposable.Create(
             bus.subscribe(SparkTags.SecuritiesTag).Subscribe(s => _securities = s),
-            bus.subscribe(SparkTags.ShowLadderTag).ObserveOnDispatcher().Subscribe(s => show_windows(new[] { s })),
-            bus.subscribe(SparkTags.ShowLaddersTag).ObserveOnDispatcher().Subscribe(show_windows)
+            bus.subscribe(SparkTags.ShowLadderTag).OnDispatcher().Subscribe(s => show_windows(new[] { s })),
+            bus.subscribe(SparkTags.ShowLaddersTag).OnDispatcher().Subscribe(show_windows)
          );
       }
 
@@ -77,6 +76,7 @@ namespace bts.shell {
                s.ask_break_line = LadderSettings.Default.ask_break_line;
             if (s.mid_break_line == null)
                s.mid_break_line = LadderSettings.Default.mid_break_line;
+            s.row_height = LadderRender.measure_row_height(s);
             return s;
          }
       }

src/client/spark/Modules/Trading/OrderBookWindowFactory.cs

@@ -17,7 +17,7 @@ namespace bts.shell {
          _bus = bus;
          _model = model;
 
-         _dispose = bus.subscribe(SparkTags.ShowOrderBookTag).ObserveOnDispatcher().Subscribe(show);
+         _dispose = bus.subscribe(SparkTags.ShowOrderBookTag).OnDispatcher().Subscribe(show);
       }
 
       public override Task<IShellWindow> load(OrderBookStartupData state) {

src/client/spark/Modules/Trading/PAndLWindowFactory.cs

@@ -17,7 +17,7 @@ namespace bts.shell {
          _bus = bus;
          _model = model;
 
-         _dispose = bus.subscribe(SparkTags.ShowPAndLTag).ObserveOnDispatcher().Subscribe(show);
+         _dispose = bus.subscribe(SparkTags.ShowPAndLTag).OnDispatcher().Subscribe(show);
       }
 
 

src/client/spark/Orders/ExistingOrderTicketVM.cs

@@ -24,7 +24,7 @@ namespace mbts.spark {
          var security_source = security_md_source.Select(smd => smd.security);
          //
          _security = backing(nameof(security), security_source, SecurityDataHelper.Defaults.SecurityImmutable);
-         properties_vm = new OrderPropertiesEditorVM(model, security_source.ObserveOnDispatcher(), order_source.Select(ot => new InlineOrderProperties(model, ot.order.Def)));
+         properties_vm = new OrderPropertiesEditorVM(model, security_source.OnDispatcher(), order_source.Select(ot => new InlineOrderProperties(model, ot.order.Def)));
          _price = backing(nameof(price), double.NaN);
          size_calculator = new CalculatorLogic(null, calculator_buttons);
          _current_price = backing(nameof(current_price), order_source.Select(ort => ort.order.State.Price));
@@ -83,15 +83,15 @@ namespace mbts.spark {
             size_calculator,
             properties_vm,
             bbo = new BBOVM(security_md_source),
-            order_source.ObserveOnDispatcher().Subscribe(ort => {
+            order_source.OnDispatcher().Subscribe(ort => {
                key = ort.order.Key;
                if (DoubleHelper.IsNaNOrInfinity(price))
                   price = ort.order.State.Price;
                if (!size_calculator.value.HasValue || !size_calculator.value_setter_called)
                   size_calculator.bypass_value_setter(ort.order.State.Quantity);
             }),
-            Observable.Merge(_price_dirty, _size_dirty, _account_dirty, _time_in_force_dirty, _order_type_dirty).ObserveOnDispatcher().Subscribe(_ => RaisePropertyChanged(nameof(dirty_items_text))),
-            _price_dirty.observe_current(true).CombineLatest(_size_dirty.observe_current(true), (pd, sd) => pd || sd).DistinctUntilChanged().ObserveOnDispatcher().Subscribe(modify_order));
+            Observable.Merge(_price_dirty, _size_dirty, _account_dirty, _time_in_force_dirty, _order_type_dirty).OnDispatcher().Subscribe(_ => RaisePropertyChanged(nameof(dirty_items_text))),
+            _price_dirty.observe_current(true).CombineLatest(_size_dirty.observe_current(true), (pd, sd) => pd || sd).DistinctUntilChanged().OnDispatcher().Subscribe(modify_order));
          this.modify_order = modify_order;
          set_price_command = new DelegateCommand<double>(_price.set);
       }

src/client/spark/Orders/FillTuple.cs

@@ -1,32 +1,53 @@
 using bts.api;
 using bts.api.orderman;
+using mbts.utils;
 using System;
 
-namespace mbts.spark
-{
+namespace mbts.spark {
    class FillTuple : IEquatable<FillTuple> {
       public readonly FillImmutable fill;
       public readonly OrderRecordImmutable? order;
-      public readonly SecurityImmutable? security;
-      public readonly string key;
+      public readonly SecurityMD? security_md;
+      public readonly FillTupleKey key;
 
-      public FillTuple(FillImmutable fill, OrderRecordImmutable? order, SecurityImmutable? security) {
+      public FillTuple(FillImmutable fill, OrderRecordImmutable? order, SecurityMD? security_md) {
          this.fill = fill;
          this.order = order;
-         this.security = security;
-         // a FillTuple that DOES NOT HAVE associated order/security needs to be distinguishable
-         // from a FillTuple (of the same underlying FillImmutable) that DOES HAVE associated order/security
-         key = fill.FillKey;
-         if (!order.HasValue) key += "!o";
-         if (!security.HasValue) key += "!s";
+         this.security_md = security_md;
+         key = new FillTupleKey(fill.FillKey, order.HasValue ? order.Value.Key : 0u, security_md.HasValue ? security_md.Value.security.Id : 0u);
       }
 
       public bool Equals(FillTuple other) => other != null
          && other.order.HasValue == order.HasValue
-         && other.security.HasValue == security.HasValue
+         && other.security_md.HasValue == security_md.HasValue
          && other.fill.Equals(fill);
 
       public override bool Equals(object obj) => Equals(obj as FillTuple);
       public override int GetHashCode() => key.GetHashCode();
    }
+
+   struct FillTupleKey : IEquatable<FillTupleKey> {
+      public readonly string fill_key;
+      public readonly uint order_key, security_key;
+
+      public FillTupleKey(string fill_key, uint order_key, uint security_key) {
+         this.fill_key = fill_key;
+         this.order_key = order_key;
+         this.security_key = security_key;
+      }
+
+      public bool Equals(FillTupleKey other) =>
+         other.order_key == order_key &&
+         other.security_key == security_key &&
+         other.fill_key == fill_key;
+
+      public override bool Equals(object obj) =>
+         obj is FillTupleKey k && Equals(k);
+
+      public override int GetHashCode() =>
+         EqualityComparer.aggregate_hash(
+            fill_key.GetHashCode(),
+            (int)order_key,
+            (int)security_key);
+   }
 }

src/client/spark/Orders/FillTupleSource.cs

@@ -1,5 +1,4 @@
-using bts.api;
-using bts.api.core;
+using bts.api.core;
 using bts.api.orderman;
 using mbts.collections;
 using mbts.utils;
@@ -7,23 +6,25 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Linq;
+using System.Reactive.Subjects;
 using System.Threading;
 
 namespace mbts.spark {
-   class FillTupleSource : IDisposable {
-      public static IObservable<ITableUpdateTransform<FillTuple, string>> create_observable(
+   class FillTupleSource : IObservable<IIncrementalUpdate<FillTuple, FillTupleKey>>, IDisposable {
+      // returns a ref-count Observable.Create-wrapper that initializes/destroys the [hot-observable] FillTupleSource.
+      // (initializes when the first subscription is made, and destroys when the last subscription is disposed).
+      public static IObservable<IIncrementalUpdate<FillTuple, FillTupleKey>> create_observable(
          IObservable<IReadOnlyDictionary<uint, SecurityMD>> securities,
          IObservable<TableUpdate<OrderRecordImmutable, uint>> orders,
-         IObservable<TableUpdate<FillImmutable, string>> fills
-      ) {
+         IObservable<TableUpdate<FillImmutable, string>> fills) {
          FillTupleSource source = null;
          int ref_count = 0;
-         return Observable.Create<TableUpdateTransform<FillTuple, string>>(observer => {
+         return Observable.Create<IIncrementalUpdate<FillTuple, FillTupleKey>>(observer => {
             if (Interlocked.Increment(ref ref_count) == 1) {
                SparkUtils.lazy_assert(source == null, () => fmt_assert_msg("source should be null, there must be a leak."));
                source = new FillTupleSource(securities, orders, fills);
             }
-            IDisposable sub = source.fill_tuples.Subscribe(observer);
+            IDisposable sub = source.Subscribe(observer);
             return Disposable.Create(() => {
                Disposable.dispose_once(ref sub);
                if (Interlocked.Decrement(ref ref_count) == 0)
@@ -33,153 +34,157 @@ namespace mbts.spark {
          string fmt_assert_msg(string msg) => $"{nameof(FillTupleSource)}.{nameof(create_observable)}: {msg}";
       }
 
+      readonly Subject<IIncrementalUpdate<FillTuple, FillTupleKey>> _subject = new Subject<IIncrementalUpdate<FillTuple, FillTupleKey>>();
+      readonly Dictionary<FillTupleKey, FillTuple> _state = new Dictionary<FillTupleKey, FillTuple>();
+      readonly SetMap<uint, string> _order_fills = new SetMap<uint, string>();
+      readonly SetMap<uint, string> _security_fills = new SetMap<uint, string>();
+      IReadOnlyDictionary<string, FillImmutable> _fills_cache = new Dictionary<string, FillImmutable>(0);
+      IReadOnlyDictionary<uint, OrderRecordImmutable> _orders_cache = new Dictionary<uint, OrderRecordImmutable>(0);
+      IReadOnlyDictionary<uint, SecurityMD> _security_md_cache = new Dictionary<uint, SecurityMD>(0);
+      // _n_write_ops should never be greater than 1, bc all 3 input observables fire 'OnDispatcher'
+      int _n_read_ops, _n_write_ops; 
       IDisposable _dispose;
 
       FillTupleSource(
          IObservable<IReadOnlyDictionary<uint, SecurityMD>> securities,
          IObservable<TableUpdate<OrderRecordImmutable, uint>> orders,
-         IObservable<TableUpdate<FillImmutable, string>> fills) {
-         State state = new State();
-         var src = Observable.FromEvent<Action<TableUpdateTransform<FillTuple, string>>, TableUpdateTransform<FillTuple, string>>(cb => _updated += cb, cb => _updated -= cb);
-         fill_tuples = Observable.Create<TableUpdateTransform<FillTuple, string>>(observer => {
-            var init_state = state.fill_tuples.state.ToDictionary();
-            observer.OnNext(new TableUpdateTransform<FillTuple, string>(init_state, init_state.Values.ToList(), new List<FillTuple>(0)));
-            return src.Subscribe(observer);
-         });
+         IObservable<TableUpdate<FillImmutable, string>> fills) =>
+         //
          _dispose = Disposable.Create(
-            securities.ObserveOnDispatcher().Subscribe(s => update(state.update_securities(s))),
-            orders.ObserveOnDispatcher().Subscribe(o => update(state.update_orders(o))),
-            fills.ObserveOnDispatcher().Subscribe(f => update(state.update_fills(f)))
-         );
-         void update(State new_state) {
-            state = new_state;
-            _updated?.Invoke(state.fill_tuples);
+            securities.OnDispatcher().Subscribe(_update_securities),
+            orders.OnDispatcher().Subscribe(_update_orders),
+            fills.OnDispatcher().Subscribe(_update_fills));
+
+      public IDisposable Subscribe(IObserver<IIncrementalUpdate<FillTuple, FillTupleKey>> observer) {
+         using (_read()) {
+            observer.OnNext(new IncrementalUpdate<FillTuple, FillTupleKey>(new Dictionary<FillTupleKey, FillTuple>(_state), new Dictionary<FillTupleKey, FillTuple>(0)));
+            return _subject.Subscribe(observer);
          }
       }
 
-      event Action<TableUpdateTransform<FillTuple, string>> _updated;
+      public void Dispose() => Disposable.dispose(ref _dispose);
 
-      IObservable<TableUpdateTransform<FillTuple, string>> fill_tuples { get; }
-
-      public void Dispose() =>
-         Disposable.dispose(ref _dispose);
-
-      class State {
-         readonly IReadOnlyDictionary<string, FillImmutable> _fills;
-         readonly IReadOnlyDictionary<uint, OrderRecordImmutable> _orders;
-         readonly IReadOnlyDictionary<uint, SecurityMD> _securities;
-         readonly TableUpdateTransform<FillTuple, string> _fill_tuples;
-         readonly SetMap<uint, string> _order_fills;
-         readonly SetMap<uint, string> _security_fills;
-
-         public State() : this(
-            new Dictionary<string, FillImmutable>(),
-            new Dictionary<uint, OrderRecordImmutable>(),
-            new Dictionary<uint, SecurityMD>(),
-            new TableUpdateTransform<FillTuple, string>(new Dictionary<string, FillTuple>(), new List<FillTuple>(), new List<FillTuple>()),
-            new SetMap<uint, string>(),
-            new SetMap<uint, string>()
-         ) { }
-
-         State(
-            IReadOnlyDictionary<string, FillImmutable> fills,
-            IReadOnlyDictionary<uint, OrderRecordImmutable> orders,
-            IReadOnlyDictionary<uint, SecurityMD> securities,
-            TableUpdateTransform<FillTuple, string> fill_tuples,
-            SetMap<uint, string> order_fill_tuples,
-            SetMap<uint, string> security_fill_tuples
-         ) {
-            _fills = fills;
-            _orders = orders;
-            _securities = securities;
-            _fill_tuples = fill_tuples;
-            _order_fills = order_fill_tuples;
-            _security_fills = security_fill_tuples;
+      void _update_fills(TableUpdate<FillImmutable, string> fills) {
+         using (_write()) {
+            Dictionary<FillTupleKey, FillTuple> removed = new Dictionary<FillTupleKey, FillTuple>(), added = new Dictionary<FillTupleKey, FillTuple>();
+            foreach (FillImmutable fill in fills.removed) {
+               FillTuple old_ft = new FillTuple(fill, _get_order(fill.OrderKey), _get_security_md(fill.SecurityKey));
+               removed.Add(old_ft.key, old_ft);
+               _security_fills.remove(fill.SecurityKey, fill.FillKey);
+               _order_fills.remove(fill.OrderKey, fill.FillKey);
+            }
+            foreach (FillImmutable fill in fills.added) {
+               FillTuple new_ft = new FillTuple(fill, _get_order(fill.OrderKey), _get_security_md(fill.SecurityKey));
+               added.Add(new_ft.key, new_ft);
+               _security_fills.add(fill.SecurityKey, fill.FillKey);
+               _order_fills.add(fill.OrderKey, fill.FillKey);
+            }
+            _fills_cache = fills.state;
+            _apply_changes(added, removed);
          }
+      }
 
-         public TableUpdateTransform<FillTuple, string> fill_tuples => _fill_tuples;
-
-         public State update_fills(TableUpdate<FillImmutable, string> fills) {
-            var removed = fills.removed.Select(get_fill_tuple).ToList();
-            var added = fills.added.Select(get_fill_tuple).ToList();
-            var order_fills = _order_fills.clone();
-            var security_fills = _security_fills.clone();
-            HashSet<string> added_keys = new HashSet<string>(fills.added.Select(f => f.FillKey)),
-               removed_keys = new HashSet<string>(fills.removed.Select(f => f.FillKey));
-            foreach (var ft in removed) {
-               string k = ft.fill.FillKey;
-               if (!added_keys.Contains(k)) {
-                  order_fills.remove(ft.fill.OrderKey, k);
-                  security_fills.remove(ft.fill.SecurityKey, k);
+      void _update_orders(TableUpdate<OrderRecordImmutable, uint> orders) {
+         using (_write()) {
+            Dictionary<FillTupleKey, FillTuple> added = new Dictionary<FillTupleKey, FillTuple>(), removed = new Dictionary<FillTupleKey, FillTuple>();
+            HashSet<uint> changed_keys = new HashSet<uint>();
+            foreach (var o in orders.removed) {
+               if (_order_fills.try_lookup(o.Key, out ISet<string> fill_keys)) {
+                  IEnumerable<FillImmutable> fills = fill_keys.Select(fk => _fills_cache[fk]);
+                  SecurityMD? sec_md = _get_security_md(o.security_key());
+                  foreach (FillImmutable fill in fills) {
+                     FillTuple old_ft = new FillTuple(fill, o, sec_md);
+                     removed.Add(old_ft.key, old_ft);
+                  }
+                  OrderRecordImmutable? curr_order = null;
+                  if (orders.try_get(o.Key, out OrderRecordImmutable newval)) {
+                     curr_order = newval;
+                     changed_keys.Add(o.Key);
+                  }
+                  foreach (FillImmutable fill in fills) {
+                     FillTuple new_ft = new FillTuple(fill, curr_order, sec_md);
+                     added.Add(new_ft.key, new_ft);
+                  }
                }
             }
-            foreach (var ft in added) {
-               string k = ft.fill.FillKey;
-               if (!removed_keys.Contains(k)) {
-                  order_fills.add(ft.fill.OrderKey, k);
-                  security_fills.add(ft.fill.SecurityKey, k);
+            foreach (var o in orders.added) {
+               if (!changed_keys.Contains(o.Key) && _order_fills.try_lookup(o.Key, out ISet<string> fill_keys)) {
+                  IEnumerable<FillImmutable> fills = fill_keys.Select(fk => _fills_cache[fk]);
+                  SecurityMD? sec_md = _get_security_md(o.security_key());
+                  foreach (FillImmutable fill in fills) {
+                     FillTuple old_ft = new FillTuple(fill, null, sec_md);
+                     removed.Add(old_ft.key, old_ft);
+                     FillTuple new_ft = new FillTuple(fill, o, sec_md);
+                     added.Add(new_ft.key, new_ft);
+                  }
                }
             }
-            return new State(fills.state, _orders, _securities, _fill_tuples.update(removed, added, f => f.key), order_fills, security_fills);
-            //
-            FillTuple get_fill_tuple(FillImmutable fill) =>
-               new FillTuple(fill, _orders.TryGetValue(fill.OrderKey, out OrderRecordImmutable o) ? o : new OrderRecordImmutable?(),
-                  _securities.TryGetValue(fill.SecurityKey, out SecurityMD s) ? s.security : new SecurityImmutable?());
+            _orders_cache = orders.state;
+            _apply_changes(added, removed);
          }
+      }
 
-         public State update_orders(TableUpdate<OrderRecordImmutable, uint> orders) {
-            List<FillTuple> added = new List<FillTuple>(), removed = new List<FillTuple>();
-            orders.detect_changed_keys(o => o.Key, out HashSet<uint> removed_keys, out HashSet<uint> added_keys, out HashSet<uint> changed_keys);
-            foreach (var k in removed_keys) {
-               if (_order_fills.try_lookup(k, out ISet<string> fill_keys)) {
-                  removed.AddRange(get_fill_tuples(_orders[k], fill_keys));
-                  added.AddRange(get_fill_tuples(null, fill_keys));
-               }
-            }
-            foreach (var k in added_keys) {
-               if (_order_fills.try_lookup(k, out ISet<string> fill_keys)) {
-                  removed.AddRange(get_fill_tuples(null, fill_keys));
-                  added.AddRange(get_fill_tuples(orders.get(k), fill_keys));
-               }
-            }
-            foreach (var k in changed_keys) {
-               if (_order_fills.try_lookup(k, out ISet<string> fill_keys)) {
-                  removed.AddRange(get_fill_tuples(_orders[k], fill_keys));
-                  added.AddRange(get_fill_tuples(orders.get(k), fill_keys));
-               }
-            }
-            return new State(_fills, orders.state, _securities, _fill_tuples.update(removed, added, ft => ft.key), _order_fills, _security_fills);
-            //
-            IEnumerable<FillTuple> get_fill_tuples(OrderRecordImmutable? o, ISet<string> fill_keys) =>
-               fill_keys.Select(k => {
-                  var fill = _fills[k];
-                  return new FillTuple(fill, o, _securities.TryGetValue(fill.SecurityKey, out SecurityMD s) ? s.security : new SecurityImmutable?());
-               });
-         }
-
-         public State update_securities(IReadOnlyDictionary<uint, SecurityMD> securities) {
-            List<FillTuple> added = new List<FillTuple>(), removed = new List<FillTuple>();
-            _securities.Keys.difference(securities.Keys, out IEnumerable<uint> added_keys, out IEnumerable<uint> removed_keys);
+      void _update_securities(IReadOnlyDictionary<uint, SecurityMD> securities) {
+         using (_write()) {
+            Dictionary<FillTupleKey, FillTuple> added = new Dictionary<FillTupleKey, FillTuple>(), removed = new Dictionary<FillTupleKey, FillTuple>();
+            _security_md_cache.Keys.difference(securities.Keys, out IEnumerable<uint> added_keys, out IEnumerable<uint> removed_keys);
             foreach (var k in removed_keys) {
                if (_security_fills.try_lookup(k, out ISet<string> fill_keys)) {
-                  removed.AddRange(get_fill_tuples(_securities[k].security, fill_keys));
-                  added.AddRange(get_fill_tuples(null, fill_keys));
+                  IEnumerable<FillImmutable> fills = fill_keys.Select(fk => _fills_cache[fk]);
+                  SecurityMD old_sec_md = _security_md_cache[k];
+                  foreach (FillImmutable fill in fills) {
+                     OrderRecordImmutable? order = _get_order(fill.OrderKey);
+                     FillTuple old_ft = new FillTuple(fill, order, old_sec_md);
+                     removed.Add(old_ft.key, old_ft);
+                     FillTuple new_ft = new FillTuple(fill, order, null);
+                     added.Add(new_ft.key, new_ft);
+                  }
                }
             }
             foreach (var k in added_keys) {
                if (_security_fills.try_lookup(k, out ISet<string> fill_keys)) {
-                  removed.AddRange(get_fill_tuples(null, fill_keys));
-                  added.AddRange(get_fill_tuples(securities[k].security, fill_keys));
+                  IEnumerable<FillImmutable> fills = fill_keys.Select(fk => _fills_cache[fk]);
+                  SecurityMD new_sec_md = securities[k];
+                  foreach (FillImmutable fill in fills) {
+                     OrderRecordImmutable? order = _get_order(fill.OrderKey);
+                     FillTuple old_ft = new FillTuple(fill, order, null);
+                     removed.Add(old_ft.key, old_ft);
+                     FillTuple new_ft = new FillTuple(fill, order, new_sec_md);
+                     added.Add(new_ft.key, new_ft);
+                  }
                }
             }
-            return new State(_fills, _orders, securities, _fill_tuples.update(removed, added, f => f.key), _order_fills, _security_fills);
-            //
-            IEnumerable<FillTuple> get_fill_tuples(SecurityImmutable? s, ISet<string> fill_keys) =>
-               fill_keys.Select(k => {
-                  var fill = _fills[k];
-                  return new FillTuple(fill, _orders.TryGetValue(fill.OrderKey, out OrderRecordImmutable o) ? o : new OrderRecordImmutable?(), s);
-               });
+            _security_md_cache = securities;
+            _apply_changes(added, removed);
          }
       }
+
+      SecurityMD? _get_security_md(uint key) =>
+         _security_md_cache.TryGetValue(key, out SecurityMD smd) ? smd : new SecurityMD?();
+
+      OrderRecordImmutable? _get_order(uint key) =>
+         _orders_cache.TryGetValue(key, out OrderRecordImmutable o) ? o : new OrderRecordImmutable?();
+
+      void _apply_changes(Dictionary<FillTupleKey, FillTuple> added, Dictionary<FillTupleKey, FillTuple> removed) {
+         foreach (var kv in removed)
+            _state.Remove(kv.Key);
+         foreach (var kv in added)
+            _state.Add(kv.Key, kv.Value);
+         _subject.OnNext(new IncrementalUpdate<FillTuple, FillTupleKey>(added, removed));
+      }
+
+      IDisposable _read() {
+         while (_n_write_ops > 0)
+            Thread.Yield();
+         Interlocked.Increment(ref _n_read_ops);
+         return Disposable.Create(() => Interlocked.Decrement(ref _n_read_ops));
+      }
+
+      IDisposable _write() {
+         while (_n_read_ops > 0)
+            Thread.Yield();
+         Interlocked.Increment(ref _n_write_ops);
+         return Disposable.Create(() => Interlocked.Decrement(ref _n_write_ops));
+      }
    }
 }

src/client/spark/Orders/NewOrderTicketVM.cs

@@ -61,7 +61,7 @@ namespace mbts.spark {
          set_price_command = new DelegateCommand<double>(set_price);
          _dispose = Disposable.Create(
             size_calculator = new CalculatorLogic(0, calculator_buttons),
-            props_source.ObserveOnDispatcher().Subscribe(p => on_props(p.price, p.size))
+            props_source.OnDispatcher().Subscribe(p => on_props(p.price, p.size))
          );
 
          void on_props(InlineUserProperty<double> price_prop, InlineUserProperty<uint> size_prop) {

src/client/spark/Orders/OrderActivitySummarizer.cs

@@ -114,7 +114,7 @@ namespace bts.spark {
             (var security, var spec) = get_security(neworder.Def.SecurityKey);
             //
             // description
-            var mod_desc = modified_description(oldorder, neworder, spec.Value);
+            var mod_desc = modified_description(oldorder, neworder, spec);
             if (!string.IsNullOrEmpty(mod_desc)) {
                log_status(ActivityLogCategory.modify, security, mod_desc);
             }

src/client/spark/Orders/OrderModificationControl.xaml.cs

@@ -20,6 +20,10 @@ namespace mbts.ui.spark {
       public DataTemplate StopLimitOrderTemplate { get; set; }
       public DataTemplate StopMarketOrderTemplate { get; set; }
       public DataTemplate TimeBoxOrderTemplate { get; set; }
+      public DataTemplate TickOrderTemplate { get; set; }
+      public DataTemplate LeanOrderTemplate { get; set; }
+      public DataTemplate JoinOrderTemplate { get; set; }
+      public DataTemplate TopOrderTemplate { get; set; }
       public DataTemplate IcebergOrderTemplate { get; set; }
       public DataTemplate SpreaderTemplate { get; set; }
       public DataTemplate BTSStopOrderTemplate { get; set; }
@@ -33,6 +37,10 @@ namespace mbts.ui.spark {
                case CustomOrderDefinition.CustomOneofCase.Stop: return StopMarketOrderTemplate;
                case CustomOrderDefinition.CustomOneofCase.StopLimit: return StopLimitOrderTemplate;
                case CustomOrderDefinition.CustomOneofCase.TimeBox: return TimeBoxOrderTemplate;
+               case CustomOrderDefinition.CustomOneofCase.Tick: return TickOrderTemplate;
+               case CustomOrderDefinition.CustomOneofCase.Lean: return LeanOrderTemplate;
+               case CustomOrderDefinition.CustomOneofCase.Join: return JoinOrderTemplate;
+               case CustomOrderDefinition.CustomOneofCase.Top: return TopOrderTemplate;
                case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate;
                case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate;
             }

src/client/spark/Orders/OrderPropertiesEditorVM.cs

@@ -46,7 +46,7 @@ namespace mbts.spark {
 
       public OrderPropertiesEditorVM(OrdersModel model, IObservable<SecurityImmutable> security_source, IObservable<InlineOrderProperties> order_properties) {
          _model = model;
-         _security = backing(nameof(security), security_source.ObserveOnDispatcher(), SecurityDataHelper.Defaults.SecurityImmutable);
+         _security = backing(nameof(security), security_source.OnDispatcher(), SecurityDataHelper.Defaults.SecurityImmutable);
          // guarentee that "this.security" will always be set before observers are notified
          // this is important bc some observers will reference "this.security" in their callbacks
          // - namely the [SelectorProperty]order_type's "get_default" function,

src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs

@@ -44,9 +44,9 @@ namespace mbts.spark {
             : base(model) {
             _security_source = security_source;
             _dispose = Disposable.Create(
-               security_source.ObserveOnDispatcher()
+               security_source.OnDispatcher()
                .Subscribe(s => _security = s),
-               inline_properties.ObserveOnDispatcher()
+               inline_properties.OnDispatcher()
                .Subscribe(p => {
                   if (_order_types.Count == 0 || p.child_order_types.force_override) {
                      _order_types.SetItems(p.child_order_types.value);

src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs

@@ -0,0 +1,287 @@
+using bts.api;
+using bts.api.orderman;
+using mbts.ui;
+using mbts.ui.utility;
+using mbts.utils;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Reactive.Linq;
+using static bts.api.orderman.CustomOrderDefinition;
+
+namespace mbts.spark 
+{
+   static partial class OrderTypeVMFactory 
+   {
+      class InlineJoinOrderProperties 
+      {
+         public InlineJoinOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types) 
+         {
+            ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
+            this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
+            this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
+
+            var hedgetype = CustomOneofCase.Lean;
+            if(!child_order_types.Contains(hedgetype))
+               hedgetype = CustomOneofCase.Limit;
+            
+            //ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types");
+            this.selected_hedge_order_type = new InlineUserProperty<CustomOneofCase>(hedgetype, true);
+            this.hedge_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
+
+            tick_offset_on_deploy = new InlineUserProperty<uint>(0, false);
+            join_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
+                              new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false);
+            enable_hedge = new InlineUserProperty<bool>(false, false);
+            hedge_ticks = new InlineUserProperty<int>(1, false);
+         }
+         public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
+         public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
+         public readonly InlineUserProperty<CustomOneofCase> selected_hedge_order_type;
+         public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> hedge_order_types;
+
+
+         public readonly InlineUserProperty<uint> tick_offset_on_deploy;
+         public readonly InlineUserProperty<bts.spark.QuantityMeasure> join_threshold;
+                  
+         public readonly InlineUserProperty<bool> enable_hedge;
+         public readonly InlineUserProperty<int> hedge_ticks;
+
+      }
+
+      class JoinOrderVM : OrderTypeVMBase<JoinOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable 
+      {
+         readonly IObservable<SecurityImmutable> _security_source;
+         SecurityImmutable? _security;
+         ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
+         ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
+         InlineJoinOrderProperties _inline_props;
+         IOrderTypeVM _child_order;
+         IDisposable _dispose, _child_order_errors_sub;
+
+         ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _hedge_order_choices;
+         IOrderTypeVM _hedge_order;
+         IDisposable _hedge_order_errors_sub;
+
+         public uint tick_offset_on_deploy { get; set; } = 0;
+         public bts.spark.QuantityMeasure join_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
+         bool _enable_hedge = false;
+         public bool enable_hedge
+         {
+            get { return _enable_hedge; }
+            set
+            {
+               _enable_hedge = value;
+               RaisePropertyChanged(nameof(enable_hedge));
+            }
+         } 
+         public int hedge_ticks { get; set; } = 1;
+
+         public JoinOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
+            : this(model, security_source, security_source.Select(s =>
+            new InlineJoinOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { }
+
+         public JoinOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
+                            IObservable<InlineJoinOrderProperties> inline_properties) : base(model) 
+         {
+            _security_source = security_source;
+            _dispose = Disposable.Create(
+               security_source.OnDispatcher()
+               .Subscribe(s => _security = s),
+               inline_properties.OnDispatcher()
+               .Subscribe(p => {
+                  if (_order_types.Count == 0 || p.child_order_types.force_override) 
+                  {
+                     _order_types.SetItems(p.child_order_types.value);
+                  }
+                  if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) 
+                  {
+                     _select_child_order(p.selected_child_order_type.value);
+                  }
+                  if (_hedge_order_choices != null && (_hedge_order == null || p.selected_hedge_order_type.force_override))
+                  {
+                     _select_hedge_order(p.selected_hedge_order_type.value);
+                  }
+                  if (p.tick_offset_on_deploy.force_override) 
+                  {
+                     tick_offset_on_deploy = p.tick_offset_on_deploy.value;
+                     RaisePropertyChanged(nameof(tick_offset_on_deploy));
+                  }
+                  if (p.join_threshold.force_override)
+                  {
+                     join_threshold = p.join_threshold.value;
+                     RaisePropertyChanged(nameof(join_threshold));
+                  }
+                  if (p.enable_hedge.force_override)
+                  {
+                     enable_hedge = p.enable_hedge.value;
+                     RaisePropertyChanged(nameof(enable_hedge));
+                  }
+                  if (p.hedge_ticks.force_override)
+                  {
+                     hedge_ticks = p.hedge_ticks.value;
+                     RaisePropertyChanged(nameof(hedge_ticks));
+                  }
+                  _inline_props = p;
+                  _validate();
+               })
+            );
+            _validate();
+         }
+         
+         public override void assign_to(CustomOrderDefinition value) 
+         {
+            if (_child_order == null)
+               _select_child_order(model.factory.default_order_type(_security.Value, true));
+            if (_hedge_order == null && enable_hedge)
+               _select_hedge_order(model.factory.default_order_type(_security.Value, true));
+            _validate();
+            if (!HasErrors) 
+            {
+               var i = factory.join_order();
+               i.TickOffsetOnDeploy = tick_offset_on_deploy;
+               i.JoinThreshold = join_threshold;
+               i.EnableHedge = enable_hedge;
+               i.HedgeTicks = hedge_ticks;
+               child_order.assign_to(i.Child);
+               if(enable_hedge && hedge_order != null)
+                  hedge_order.assign_to(i.Hedge);
+               value.Join = i;
+            }
+         }         
+
+         public ICollection<IOrderTypeVM> child_order_types 
+         {
+            get 
+            {
+               if (_child_order_choices == null) 
+                  _child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
+               return _child_order_choices;
+            }
+         }
+
+         public ICollection<IOrderTypeVM> hedge_order_types
+         {
+            get
+            {
+               if (_hedge_order_choices == null)
+                  _hedge_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
+               return _hedge_order_choices;
+            }
+         }         
+ 
+         public IOrderTypeVM child_order 
+         {
+            get 
+            {
+               init();
+               return _child_order;
+            }
+            set 
+            {
+               Disposable.dispose(ref _child_order_errors_sub);
+               _child_order = value;
+               _child_order?.init();
+               if (_child_order is INotifyDataErrorInfo ndei) 
+               {
+                  ndei.ErrorsChanged += on_errors_changed;
+                  void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
+                     _validate();
+                  _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
+               }
+               _validate();
+               RaisePropertyChanged(nameof(child_order));
+            }
+         }
+
+         public IOrderTypeVM hedge_order
+         {
+            get
+            {
+               init();
+               return _hedge_order;
+            }
+            set
+            {
+               Disposable.dispose(ref _hedge_order_errors_sub);
+               _hedge_order = value;
+               _hedge_order?.init();
+               if (_hedge_order is INotifyDataErrorInfo ndei)
+               {
+                  ndei.ErrorsChanged += on_errors_changed;
+                  void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
+                     _validate();
+                  _hedge_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
+               }
+               _validate();
+               RaisePropertyChanged(nameof(hedge_order));
+            }
+         }
+
+         public void Dispose() 
+         {
+            Disposable.dispose(ref _dispose);
+            if (_child_order_choices != null)
+               _child_order_choices.OfType<IDisposable>().DisposeAll();
+            if (_hedge_order_choices != null)
+               _hedge_order_choices.OfType<IDisposable>().DisposeAll();
+         }
+
+         public override void init() 
+         {
+            if (_child_order == null && _security.HasValue)
+               _select_child_order();
+            if (_hedge_order == null && _security.HasValue && enable_hedge)
+               _select_hedge_order();
+            _validate();
+         }
+
+         void _select_child_order() 
+         {
+            CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
+               _inline_props.selected_child_order_type.value :
+               model.factory.default_order_type(_security.Value, true);
+            _select_child_order(ot);
+         }
+
+         void _select_child_order(CustomOneofCase ot) 
+         {
+            _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
+            if (_child_order == null)
+               _child_order = child_order_types.FirstOrDefault();
+            RaisePropertyChanged(nameof(child_order));
+         }
+         
+         void _select_hedge_order()
+         {
+            CustomOneofCase ot = _inline_props != null && _inline_props.selected_hedge_order_type.has_value ?
+               _inline_props.selected_hedge_order_type.value :
+               model.factory.default_order_type(_security.Value, true);
+            _select_hedge_order(ot);
+         }
+
+         void _select_hedge_order(CustomOneofCase ot)
+         {
+            _hedge_order = hedge_order_types.FirstOrDefault(vm => vm.order_type == ot);
+            if (_hedge_order == null)
+               _hedge_order = hedge_order_types.FirstOrDefault();
+            RaisePropertyChanged(nameof(hedge_order));
+         }         
+         
+
+         void _validate() 
+         {
+            if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
+               set_error(nameof(child_order), string.Empty, true);
+            else clear_error(nameof(child_order));
+
+            if ( (_hedge_order == null && enable_hedge) || (_hedge_order is INotifyDataErrorInfo hdei && hdei.HasErrors))
+               set_error(nameof(hedge_order), string.Empty, true);
+            else clear_error(nameof(hedge_order));
+
+         }
+      }
+   }
+}

src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs

@@ -0,0 +1,174 @@
+using bts.api;
+using bts.api.orderman;
+using mbts.ui;
+using mbts.ui.utility;
+using mbts.utils;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Reactive.Linq;
+using static bts.api.orderman.CustomOrderDefinition;
+
+namespace mbts.spark 
+{
+   static partial class OrderTypeVMFactory 
+   {
+      class InlineLeanOrderProperties 
+      {
+         public InlineLeanOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types) 
+         {
+            ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
+            this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
+            this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
+            cross_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
+                              new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false);
+            max_chase_ticks = new InlineUserProperty<uint>(10, false);
+         }
+         public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
+         public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
+         
+         public readonly InlineUserProperty<bts.spark.QuantityMeasure> cross_threshold;
+         public readonly InlineUserProperty<uint> max_chase_ticks;
+      }
+
+      class LeanOrderVM : OrderTypeVMBase<LeanOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable 
+      {
+         readonly IObservable<SecurityImmutable> _security_source;
+         SecurityImmutable? _security;
+         ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
+         ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
+         InlineLeanOrderProperties _inline_props;
+         IOrderTypeVM _child_order;
+         IDisposable _dispose, _child_order_errors_sub;
+         
+         public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
+         public uint max_chase_ticks { get; set; } = 10;
+
+         public LeanOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
+            : this(model, security_source, security_source.Select(s =>
+            new InlineLeanOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { }
+
+         public LeanOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
+                            IObservable<InlineLeanOrderProperties> inline_properties) : base(model) 
+         {
+            _security_source = security_source;
+            _dispose = Disposable.Create(
+               security_source.OnDispatcher()
+               .Subscribe(s => _security = s),
+               inline_properties.OnDispatcher()
+               .Subscribe(p => {
+                  if (_order_types.Count == 0 || p.child_order_types.force_override) 
+                  {
+                     _order_types.SetItems(p.child_order_types.value);
+                  }
+                  if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) 
+                  {
+                     _select_child_order(p.selected_child_order_type.value);
+                  }                  
+                  if (p.cross_threshold.force_override)
+                  {
+                     cross_threshold = p.cross_threshold.value;
+                     RaisePropertyChanged(nameof(cross_threshold));
+                  }
+                  if (p.max_chase_ticks.force_override)
+                  {
+                     max_chase_ticks = p.max_chase_ticks.value;
+                     RaisePropertyChanged(nameof(max_chase_ticks));
+                  }
+                  _inline_props = p;
+                  _validate();
+               })
+            );
+            _validate();
+         }
+         
+         public override void assign_to(CustomOrderDefinition value) 
+         {
+            if (_child_order == null)
+               _select_child_order(model.factory.default_order_type(_security.Value, true));
+            _validate();
+            if (!HasErrors) 
+            {
+               var i = factory.lean_order();
+               i.CrossThreshold = cross_threshold;
+               i.MaxChaseTicks = max_chase_ticks;
+               child_order.assign_to(i.Child);
+               value.Lean = i;
+            }
+         }         
+
+         public ICollection<IOrderTypeVM> child_order_types 
+         {
+            get 
+            {
+               if (_child_order_choices == null) 
+                  _child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
+               return _child_order_choices;
+            }
+         }
+ 
+         public IOrderTypeVM child_order 
+         {
+            get 
+            {
+               init();
+               return _child_order;
+            }
+            set 
+            {
+               Disposable.dispose(ref _child_order_errors_sub);
+               _child_order = value;
+               _child_order?.init();
+               if (_child_order is INotifyDataErrorInfo ndei) 
+               {
+                  ndei.ErrorsChanged += on_errors_changed;
+                  void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
+                     _validate();
+                  _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
+               }
+               _validate();
+               RaisePropertyChanged(nameof(child_order));
+            }
+         }         
+
+         public void Dispose() 
+         {
+            Disposable.dispose(ref _dispose);
+            if (_child_order_choices != null)
+               _child_order_choices.OfType<IDisposable>().DisposeAll();
+         }
+
+         public override void init() 
+         {
+            if (_child_order == null && _security.HasValue)
+               _select_child_order();
+            _validate();
+         }
+
+         void _select_child_order() 
+         {
+            CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
+               _inline_props.selected_child_order_type.value :
+               model.factory.default_order_type(_security.Value, true);
+            _select_child_order(ot);
+         }
+
+         void _select_child_order(CustomOneofCase ot) 
+         {
+            _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
+            if (_child_order == null)
+               _child_order = child_order_types.FirstOrDefault();
+            RaisePropertyChanged(nameof(child_order));
+         }
+
+         void _validate() 
+         {
+            if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
+               set_error(nameof(child_order), string.Empty, true);
+            else clear_error(nameof(child_order));
+         }
+      }
+   }
+}

src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs

@@ -14,6 +14,10 @@ namespace mbts.spark {
       public static IOrderTypeVM stop(OrdersModel model) => new StopOrderVM(model);
       public static IOrderTypeVM stop_limit(OrdersModel model) => new StopLimitOrderVM(model);
       public static IOrderTypeVM time_box(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TimeBoxOrderVM(model, security_source);
+      public static IOrderTypeVM tick(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TickOrderVM(model, security_source);
+      public static IOrderTypeVM lean(OrdersModel model, IObservable<SecurityImmutable> security_source) => new LeanOrderVM(model, security_source);
+      public static IOrderTypeVM join(OrdersModel model, IObservable<SecurityImmutable> security_source) => new JoinOrderVM(model, security_source);
+      public static IOrderTypeVM top(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TopOrderVM(model, security_source);
       public static IOrderTypeVM iceberg(OrdersModel model, IObservable<SecurityImmutable> security_source) => new IcebergOrderVM(model, security_source);
       public static IOrderTypeVM spreader(OrdersModel model, IObservable<SecurityImmutable> security_source) => new SpreaderOrderVM(model, security_source);
 
@@ -27,6 +31,10 @@ namespace mbts.spark {
             case CustomOneofCase.Stop: return stop(model);
             case CustomOneofCase.StopLimit: return stop_limit(model);
             case CustomOneofCase.TimeBox: return time_box(model, security_source);
+            case CustomOneofCase.Tick: return tick(model, security_source);
+            case CustomOneofCase.Lean: return lean(model, security_source);
+            case CustomOneofCase.Join: return join(model, security_source);
+            case CustomOneofCase.Top: return top(model, security_source);
             case CustomOneofCase.Iceberg: return iceberg(model, security_source);
             case CustomOneofCase.Spreader: return spreader(model, security_source);
             default: throw new NotImplementedException();

src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs

@@ -1,15 +1,17 @@
 using bts.api;
 using bts.api.orderman;
 using mbts.ui;
+using mbts.ui.controls;
 using System;
+using System.Collections.Generic;
 using System.Reactive.Linq;
 
 namespace mbts.spark {
    static partial class OrderTypeVMFactory {
       private class SpreaderOrderVM : OrderTypeVMBase<SpreaderOrderDefinition>, IOrderTypeVM, IDisposable {
          readonly Property<SpreaderOrderDefinitionImmutable?> _template;
+         readonly StrategyEditorWrapper _strategy_editor_wrapper;
          IDisposable _dispose;
-         SyntheticEditorVM _strategy_editor;
 
          public SpreaderOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
             : this(model, security_source, security_source.SelectMany(s => model.spreader.security_strategy(s.Id)
@@ -26,15 +28,15 @@ namespace mbts.spark {
             IObservable<InlineUserProperty<SpreaderOrderDefinitionImmutable>> order_template_source)
             : base(model) {
             _template = backing(nameof(template), new SpreaderOrderDefinitionImmutable?());
+            _strategy_editor_wrapper = new StrategyEditorWrapper(this);
             _dispose = Disposable.Create(
-               _template.ObserveOnDispatcher().Subscribe(vals => {
+               _strategy_editor_wrapper,
+               _template.OnDispatcher().Subscribe(vals => {
                   _validate();
                }),
-               order_template_source.ObserveOnDispatcher().Subscribe(prop => {
+               order_template_source.OnDispatcher().Subscribe(prop => {
                   if (prop.force_override || (!template.HasValue && prop.has_value)) {
                      _template.Value = prop.value;
-                     if (_strategy_editor != null)
-                        _strategy_editor.set_synthetic(prop.value.Security, prop.value.ExecutionStrategy);
                      _validate();
                   }
                })
@@ -43,23 +45,14 @@ namespace mbts.spark {
          }
 
          public SpreaderOrderDefinitionImmutable? template => _template.Value;
-
-         public SyntheticEditorVM strategy_editor {
-            get {
-               if (_strategy_editor == null && template.HasValue) {
-                  var def = template.Value;
-                  _strategy_editor = new SyntheticEditorVM(model.spreader, def.Security, def.ExecutionStrategy, model.security_has_working_orders(def.Security.Id));
-               }
-               return _strategy_editor;
-            }
-         }
-
+         public SyntheticEditorVM strategy_editor => _strategy_editor_wrapper.vm;
+         public IEnumerable<DialogSkirtItem> skirt_items => _strategy_editor_wrapper.skirt_items;
          public override bool editable_properties_open {
             get => base.editable_properties_open;
             set {
-               if (!value && template.HasValue && _strategy_editor != null) {
+               if (!value && template.HasValue && strategy_editor != null) {
                   var mutable_template = template.Value.CloneToMutable();
-                  mutable_template.ExecutionStrategy = _strategy_editor.get_strategy().CloneToMutable();
+                  mutable_template.ExecutionStrategy = _strategy_editor_wrapper.vm.get_strategy().CloneToMutable();
                   _template.Value = new SpreaderOrderDefinitionImmutable(mutable_template);
                }
                base.editable_properties_open = value;
@@ -80,6 +73,39 @@ namespace mbts.spark {
                set_error(nameof(template), "Waiting for security and/or strategy.", true);
             else clear_error(nameof(template));
          }
+
+         // lazily initializes SyntheticEditorVM and associated dialog skirt items
+         class StrategyEditorWrapper : IDisposable {
+            readonly SpreaderOrderVM _owner;
+            SyntheticEditorVM _vm;
+            DialogSkirtItem _save_strategy_item;
+
+            public StrategyEditorWrapper(SpreaderOrderVM owner) {
+               _owner = owner;
+               _owner._template.Changed += _order_template_changed;
+            }
+
+            public SyntheticEditorVM vm { get { _init(); return _vm; } }
+            public IEnumerable<DialogSkirtItem> skirt_items { get { _init(); yield return _save_strategy_item; } }
+
+            public void Dispose() {
+               Disposable.dispose(ref _vm);
+               _owner._template.Changed -= _order_template_changed;
+            }
+
+            void _init() {
+               if (_vm == null && _owner.template.HasValue) {
+                  var def = _owner.template.Value;
+                  _vm = new SyntheticEditorVM(_owner.model.spreader, def.Security, def.ExecutionStrategy, _owner.model.security_has_working_orders(def.Security.Id));
+                  _save_strategy_item = new DialogSkirtItem("Save Strategy", _vm.commit);
+               }
+            }
+
+            void _order_template_changed(SpreaderOrderDefinitionImmutable? oldval, SpreaderOrderDefinitionImmutable? newval) {
+               if (_vm != null && newval.HasValue)
+                  _vm.set_synthetic(newval.Value.Security, newval.Value.ExecutionStrategy);
+            }
+         }
       }
    }
 }

src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs

@@ -0,0 +1,201 @@
+using bts.api;
+using bts.api.orderman;
+using mbts.ui;
+using mbts.ui.utility;
+using mbts.utils;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Reactive.Linq;
+using static bts.api.orderman.CustomOrderDefinition;
+
+namespace mbts.spark 
+{
+   static partial class OrderTypeVMFactory 
+   {
+      class InlineTickOrderProperties 
+      {
+         public InlineTickOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types) 
+         {
+            ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
+            this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
+            this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
+            tick_offset_on_deploy = new InlineUserProperty<uint>(0, false);
+            cross_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
+                              new bts.spark.QuantityMeasure() { Ratio = 1.0,  Absolute = 1}, false);
+            cross_ticks = new InlineUserProperty<uint>(0, false);
+            max_chase_ticks = new InlineUserProperty<uint>(10, false);
+            detach_on_toward = new InlineUserProperty<bool>(true, false);
+         }
+         public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
+         public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
+         
+         public readonly InlineUserProperty<uint> tick_offset_on_deploy;
+         public readonly InlineUserProperty<bts.spark.QuantityMeasure> cross_threshold;
+         public readonly InlineUserProperty<uint> cross_ticks;
+         public readonly InlineUserProperty<uint> max_chase_ticks;
+         public readonly InlineUserProperty<bool> detach_on_toward;
+      }
+
+      class TickOrderVM : OrderTypeVMBase<TickOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable 
+      {
+         readonly IObservable<SecurityImmutable> _security_source;
+         SecurityImmutable? _security;
+         ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
+         ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
+         InlineTickOrderProperties _inline_props;
+         IOrderTypeVM _child_order;
+         IDisposable _dispose, _child_order_errors_sub;
+         
+         public uint tick_offset_on_deploy { get; set; } = 0;
+         public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
+         public uint cross_ticks { get; set; } = 0;
+         public uint max_chase_ticks { get; set; } = 10;
+         public bool detach_on_toward { get; set; } = true;         
+
+         public TickOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
+            : this(model, security_source, security_source.Select(s =>
+            new InlineTickOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { }
+
+         public TickOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
+                            IObservable<InlineTickOrderProperties> inline_properties) : base(model) 
+         {
+            _security_source = security_source;
+            _dispose = Disposable.Create(
+               security_source.OnDispatcher()
+               .Subscribe(s => _security = s),
+               inline_properties.OnDispatcher()
+               .Subscribe(p => {
+                  if (_order_types.Count == 0 || p.child_order_types.force_override) 
+                  {
+                     _order_types.SetItems(p.child_order_types.value);
+                  }
+                  if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) 
+                  {
+                     _select_child_order(p.selected_child_order_type.value);
+                  }                  
+                  if (p.tick_offset_on_deploy.force_override) 
+                  {
+                     tick_offset_on_deploy = p.tick_offset_on_deploy.value;
+                     RaisePropertyChanged(nameof(tick_offset_on_deploy));
+                  }
+                  if (p.cross_threshold.force_override)
+                  {
+                     cross_threshold = p.cross_threshold.value;
+                     RaisePropertyChanged(nameof(cross_threshold));
+                  }
+                  if (p.cross_ticks.force_override)
+                  {
+                     cross_ticks = p.cross_ticks.value;
+                     RaisePropertyChanged(nameof(cross_ticks));
+                  }
+                  if (p.max_chase_ticks.force_override)
+                  {
+                     max_chase_ticks = p.max_chase_ticks.value;
+                     RaisePropertyChanged(nameof(max_chase_ticks));
+                  }
+                  if (p.detach_on_toward.force_override)
+                  {
+                     detach_on_toward = p.detach_on_toward.value;
+                     RaisePropertyChanged(nameof(detach_on_toward));
+                  }                                                                        
+                  _inline_props = p;
+                  _validate();
+               })
+            );
+            _validate();
+         }
+         
+         public override void assign_to(CustomOrderDefinition value) 
+         {
+            if (_child_order == null)
+               _select_child_order(model.factory.default_order_type(_security.Value, true));
+            _validate();
+            if (!HasErrors) 
+            {
+               var i = factory.tick_order();
+               i.TickOffsetOnDeploy = tick_offset_on_deploy;
+               i.CrossThreshold = cross_threshold;
+               i.CrossTicks = cross_ticks;
+               i.MaxChaseTicks = max_chase_ticks;
+               i.DetachOnToward = detach_on_toward;
+               child_order.assign_to(i.Child);
+               value.Tick = i;
+            }
+         }         
+
+         public ICollection<IOrderTypeVM> child_order_types 
+         {
+            get 
+            {
+               if (_child_order_choices == null) 
+                  _child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
+               return _child_order_choices;
+            }
+         }
+ 
+         public IOrderTypeVM child_order 
+         {
+            get 
+            {
+               init();
+               return _child_order;
+            }
+            set 
+            {
+               Disposable.dispose(ref _child_order_errors_sub);
+               _child_order = value;
+               _child_order?.init();
+               if (_child_order is INotifyDataErrorInfo ndei) 
+               {
+                  ndei.ErrorsChanged += on_errors_changed;
+                  void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
+                     _validate();
+                  _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
+               }
+               _validate();
+               RaisePropertyChanged(nameof(child_order));
+            }
+         }         
+
+         public void Dispose() 
+         {
+            Disposable.dispose(ref _dispose);
+            if (_child_order_choices != null)
+               _child_order_choices.OfType<IDisposable>().DisposeAll();
+         }
+
+         public override void init() 
+         {
+            if (_child_order == null && _security.HasValue)
+               _select_child_order();
+            _validate();
+         }
+
+         void _select_child_order() 
+         {
+            CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
+               _inline_props.selected_child_order_type.value :
+               model.factory.default_order_type(_security.Value, true);
+            _select_child_order(ot);
+         }
+
+         void _select_child_order(CustomOneofCase ot) 
+         {
+            _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
+            if (_child_order == null)
+               _child_order = child_order_types.FirstOrDefault();
+            RaisePropertyChanged(nameof(child_order));
+         }
+
+         void _validate() 
+         {
+            if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
+               set_error(nameof(child_order), string.Empty, true);
+            else clear_error(nameof(child_order));
+         }
+      }
+   }
+}

src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs

@@ -50,9 +50,9 @@ namespace mbts.spark {
             : base(model) {
             _security_source = security_source;
             _dispose = Disposable.Create(
-               security_source.ObserveOnDispatcher()
+               security_source.OnDispatcher()
                .Subscribe(s => _security = s),
-               inline_properties.ObserveOnDispatcher()
+               inline_properties.OnDispatcher()
                .Subscribe(p => {
                   if (_order_types.Count == 0 || p.child_order_types.force_override) {
                      _order_types.SetItems(p.child_order_types.value);

src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs

@@ -0,0 +1,287 @@
+using bts.api;
+using bts.api.orderman;
+using mbts.ui;
+using mbts.ui.utility;
+using mbts.utils;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Reactive.Linq;
+using static bts.api.orderman.CustomOrderDefinition;
+
+namespace mbts.spark
+{
+   static partial class OrderTypeVMFactory
+   {
+      class InlineTopOrderProperties
+      {
+         public InlineTopOrderProperties(CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types)
+         {
+            ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
+            this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
+            this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
+
+            var hedgetype = CustomOneofCase.Lean;
+            if(!child_order_types.Contains(hedgetype))
+               hedgetype = CustomOneofCase.Limit;
+            this.selected_hedge_order_type = new InlineUserProperty<CustomOneofCase>(hedgetype, true);
+            this.hedge_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
+
+            watch_level_tick_offset = new InlineUserProperty<uint>(0, false);
+            top_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
+                              new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }, false);
+            enable_hedge = new InlineUserProperty<bool>(false, false);
+            hedge_ticks = new InlineUserProperty<int>(1, false);
+         }
+         public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
+         public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
+         public readonly InlineUserProperty<CustomOneofCase> selected_hedge_order_type;
+         public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> hedge_order_types;
+
+
+         public readonly InlineUserProperty<uint> watch_level_tick_offset;
+         public readonly InlineUserProperty<bts.spark.QuantityMeasure> top_threshold;
+
+         public readonly InlineUserProperty<bool> enable_hedge;
+         public readonly InlineUserProperty<int> hedge_ticks;
+
+      }
+
+      class TopOrderVM : OrderTypeVMBase<TopOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable
+      {
+         readonly IObservable<SecurityImmutable> _security_source;
+         SecurityImmutable? _security;
+         ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
+         ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
+         InlineTopOrderProperties _inline_props;
+         IOrderTypeVM _child_order;
+         IDisposable _dispose, _child_order_errors_sub;
+
+         ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _hedge_order_choices;
+         IOrderTypeVM _hedge_order;
+         IDisposable _hedge_order_errors_sub;
+
+         public uint watch_level_tick_offset { get; set; } = 0;
+         public bts.spark.QuantityMeasure top_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
+         bool _enable_hedge = false;
+         public bool enable_hedge
+         {
+            get { return _enable_hedge; }
+            set
+            {
+               _enable_hedge = value;
+               RaisePropertyChanged(nameof(enable_hedge));
+            }
+         }
+         public int hedge_ticks { get; set; } = 1;
+
+         public TopOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
+            : this(model, security_source, security_source.Select(s =>
+            new InlineTopOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList())))
+         { }
+
+         public TopOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
+                            IObservable<InlineTopOrderProperties> inline_properties) : base(model)
+         {
+            _security_source = security_source;
+            _dispose = Disposable.Create(
+               security_source.OnDispatcher()
+               .Subscribe(s => _security = s),
+               inline_properties.OnDispatcher()
+               .Subscribe(p =>
+               {
+                  if (_order_types.Count == 0 || p.child_order_types.force_override)
+                  {
+                     _order_types.SetItems(p.child_order_types.value);
+                  }
+                  if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override))
+                  {
+                     _select_child_order(p.selected_child_order_type.value);
+                  }
+                  if (_hedge_order_choices != null && (_hedge_order == null || p.selected_hedge_order_type.force_override))
+                  {
+                     _select_hedge_order(p.selected_hedge_order_type.value);
+                  }
+                  if (p.watch_level_tick_offset.force_override)
+                  {
+                     watch_level_tick_offset = p.watch_level_tick_offset.value;
+                     RaisePropertyChanged(nameof(watch_level_tick_offset));
+                  }
+                  if (p.top_threshold.force_override)
+                  {
+                     top_threshold = p.top_threshold.value;
+                     RaisePropertyChanged(nameof(top_threshold));
+                  }
+                  if (p.enable_hedge.force_override)
+                  {
+                     enable_hedge = p.enable_hedge.value;
+                     RaisePropertyChanged(nameof(enable_hedge));
+                  }
+                  if (p.hedge_ticks.force_override)
+                  {
+                     hedge_ticks = p.hedge_ticks.value;
+                     RaisePropertyChanged(nameof(hedge_ticks));
+                  }
+                  _inline_props = p;
+                  _validate();
+               })
+            );
+            _validate();
+         }
+
+         public override void assign_to(CustomOrderDefinition value)
+         {
+            if (_child_order == null)
+               _select_child_order(model.factory.default_order_type(_security.Value, true));
+            if (_hedge_order == null && enable_hedge)
+               _select_hedge_order(model.factory.default_order_type(_security.Value, true));
+            _validate();
+            if (!HasErrors)
+            {
+               var i = factory.top_order();
+               i.WatchLevelTickOffset = watch_level_tick_offset;
+               i.TopThreshold = top_threshold;
+               i.EnableHedge = enable_hedge;
+               i.HedgeTicks = hedge_ticks;
+               child_order.assign_to(i.Child);
+               if (enable_hedge && hedge_order != null)
+                  hedge_order.assign_to(i.Hedge);
+               value.Top = i;
+            }
+         }
+
+         public ICollection<IOrderTypeVM> child_order_types
+         {
+            get
+            {
+               if (_child_order_choices == null)
+                  _child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
+               return _child_order_choices;
+            }
+         }
+
+         public ICollection<IOrderTypeVM> hedge_order_types
+         {
+            get
+            {
+               if (_hedge_order_choices == null)
+                  _hedge_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
+               return _hedge_order_choices;
+            }
+         }
+
+         public IOrderTypeVM child_order
+         {
+            get
+            {
+               init();
+               return _child_order;
+            }
+            set
+            {
+               Disposable.dispose(ref _child_order_errors_sub);
+               _child_order = value;
+               _child_order?.init();
+               if (_child_order is INotifyDataErrorInfo ndei)
+               {
+                  ndei.ErrorsChanged += on_errors_changed;
+                  void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
+                     _validate();
+                  _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
+               }
+               _validate();
+               RaisePropertyChanged(nameof(child_order));
+            }
+         }
+
+         public IOrderTypeVM hedge_order
+         {
+            get
+            {
+               init();
+               return _hedge_order;
+            }
+            set
+            {
+               Disposable.dispose(ref _hedge_order_errors_sub);
+               _hedge_order = value;
+               _hedge_order?.init();
+               if (_hedge_order is INotifyDataErrorInfo ndei)
+               {
+                  ndei.ErrorsChanged += on_errors_changed;
+                  void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
+                     _validate();
+                  _hedge_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
+               }
+               _validate();
+               RaisePropertyChanged(nameof(hedge_order));
+            }
+         }
+
+         public void Dispose()
+         {
+            Disposable.dispose(ref _dispose);
+            if (_child_order_choices != null)
+               _child_order_choices.OfType<IDisposable>().DisposeAll();
+            if (_hedge_order_choices != null)
+               _hedge_order_choices.OfType<IDisposable>().DisposeAll();
+         }
+
+         public override void init()
+         {
+            if (_child_order == null && _security.HasValue)
+               _select_child_order();
+            if (_hedge_order == null && _security.HasValue && enable_hedge)
+               _select_hedge_order();
+            _validate();
+         }
+
+         void _select_child_order()
+         {
+            CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
+               _inline_props.selected_child_order_type.value :
+               model.factory.default_order_type(_security.Value, true);
+            _select_child_order(ot);
+         }
+
+         void _select_child_order(CustomOneofCase ot)
+         {
+            _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
+            if (_child_order == null)
+               _child_order = child_order_types.FirstOrDefault();
+            RaisePropertyChanged(nameof(child_order));
+         }
+
+         void _select_hedge_order()
+         {
+            CustomOneofCase ot = _inline_props != null && _inline_props.selected_hedge_order_type.has_value ?
+               _inline_props.selected_hedge_order_type.value :
+               model.factory.default_order_type(_security.Value, true);
+            _select_hedge_order(ot);
+         }
+
+         void _select_hedge_order(CustomOneofCase ot)
+         {
+            _hedge_order = hedge_order_types.FirstOrDefault(vm => vm.order_type == ot);
+            if (_hedge_order == null)
+               _hedge_order = hedge_order_types.FirstOrDefault();
+            RaisePropertyChanged(nameof(hedge_order));
+         }
+
+
+         void _validate()
+         {
+            if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
+               set_error(nameof(child_order), string.Empty, true);
+            else clear_error(nameof(child_order));
+
+            if ((_hedge_order == null && enable_hedge) || (_hedge_order is INotifyDataErrorInfo hdei && hdei.HasErrors))
+               set_error(nameof(hedge_order), string.Empty, true);
+            else clear_error(nameof(hedge_order));
+
+         }
+      }
+   }
+}

src/client/spark/Orders/OrdersModel.cs

@@ -31,11 +31,11 @@ namespace mbts.spark {
          _service = service;
          _spreader = spreader;
          _error = error;
-         on_orders = _service.subscribei_orders().Table().Replay(1).RefCount();
+         on_orders = _service.subscribei_orders().Table().Cache();
          IReadOnlyDictionary<uint, OrderRecordImmutable> empty_orders = new Dictionary<uint, OrderRecordImmutable>();
          working_orders = 
             on_orders.Scan(empty_orders, (worders, table) => _update_working_orders(worders, table)).Replay(1).RefCount();
-         on_fills = _service.subscribei_fills().Table().Replay(1).RefCount();
+         on_fills = _service.subscribei_fills().Table().Cache();
          _activity = new OrderActivitySummarizer(bus, on_orders);
          on_fill_tuples = FillTupleSource.create_observable(bus.subscribe(SparkTags.SecuritiesTag), on_orders, on_fills);
          _security_orders_demuxer = new TableUpdateDemuxer<OrderRecordImmutable, uint, uint>(o => o.Key, o => o.security_key());
@@ -53,7 +53,7 @@ namespace mbts.spark {
       public SpreaderModel spreader => _spreader;
       public IObservable<TableUpdate<OrderRecordImmutable, uint>> on_orders { get; }
       public IObservable<TableUpdate<FillImmutable, string>> on_fills { get; }
-      public IObservable<ITableUpdateTransform<FillTuple, string>> on_fill_tuples { get; }
+      public IObservable<IIncrementalUpdate<FillTuple, FillTupleKey>> on_fill_tuples { get; }
       public IObservable<IReadOnlyDictionary<uint,OrderRecordImmutable>> working_orders { get; }
 
       public IObservable<ITableUpdateTransform<OrderRecordImmutable, uint>> on_security_orders(uint security) =>

src/client/spark/Spark.csproj

@@ -15,7 +15,7 @@
     <OutputType>WinExe</OutputType>
     <StartupObject>mbts.ui.shell.App</StartupObject>
     <RootNamespace>bts</RootNamespace>
-    <LangVersion>7.1</LangVersion>
+    <LangVersion>7.2</LangVersion>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <WarningsAsErrors /> 
     <Version>1.0.0</Version>   

src/client/spark/core/Bus/SparkCommand.cs

@@ -175,8 +175,8 @@ namespace bts.spark
       public SparkCommandParamObserver(string title, ImageSource icon, ITag<T> tag, IObservable<T> parameter, IObservable<bool> can_execute) : base(title, icon) {
          _tag = tag;
          _subs = Disposable.Create(
-            parameter.ObserveOnDispatcher().Subscribe(p => _parameter = p),
-            can_execute.ObserveOnDispatcher().Subscribe(ce => {
+            parameter.OnDispatcher().Subscribe(p => _parameter = p),
+            can_execute.OnDispatcher().Subscribe(ce => {
                _can_execute = ce;
                raiseCanExecuteChanged();
             })

src/client/spark/core/FontsAndColors/BTSColors.cs

@@ -199,10 +199,10 @@ namespace mbts.ui {
          public static BTSColor straddle_theovsmarket_positive { get { return BTSCoreColors.green_light; } }
 
          // Order Types
-         public static BTSColor tick_order { get { return new BTSColor(31, 4, 57);}}
-         public static BTSColor lean_order { get { return new BTSColor(110, 77, 143);}}
-         public static BTSColor join_order { get { return new BTSColor(15, 1, 29);}}
-         public static BTSColor leader_order { get { return new BTSColor(40, 9, 72);}}
+         public static BTSColor tick_order { get { return BTSColors.purple.rgb_color();}}
+         public static BTSColor lean_order { get { return BTSColors.purple.rgb_color();}}
+         public static BTSColor join_order { get { return BTSColors.purple.rgb_color();}}
+         public static BTSColor top_order { get { return BTSColors.purple.rgb_color();}}
       }
 
       public static class AW2 {

src/client/spark/core/GlobalExtensions/GlobalExtensions.cs

@@ -345,6 +345,17 @@ namespace System.Reactive.Linq
 
       public static async Task<(TResult result, bool success)> FirstAsyncTask<T, TResult>(this IObservable<T> source, Func<T, bool> predicate, Func<T, TResult> selector, TimeSpan timeout) where T : class =>
          await source.Where(predicate).Select(val => (selector(val), true)).Merge(Observable.Return((default(TResult), false)).Delay(timeout)).FirstAsync();
+
+      // This is placed here to intentionally make ObserveOnDispatcher ambiguous with the one provided by Rx
+      public static IObservable<T> ObserveOnDispatcher<T>(this IObservable<T> source) {
+         throw new InvalidOperationException("This method can starve the UI of input messages. Please use OnDispatcher() instead");
+      }
+
+      public static IObservable<T> OnDispatcher<T>(this IObservable<T> source) {
+         return DispatcherObservable.ObserveOnDispatcher(source, DispatcherPriority.Background);
+      }
+
+
    }
 }
 

src/client/spark/core/GlobalExtensions/ObjectHelper.cs

@@ -54,5 +54,33 @@
          rv |= try_convert(args[1], out arg2);
          return rv;
       }
+
+      public static bool try_convert_args<T1, T2, T3>(object[] args, out T1 arg1, out T2 arg2, out T3 arg3) {
+         if (args == null || args.Length != 3) {
+            arg1 = default;
+            arg2 = default;
+            arg3 = default;
+            return false;
+         }
+         bool rv = try_convert(args[0], out arg1);
+         rv |= try_convert(args[1], out arg2);
+         rv |= try_convert(args[2], out arg3);
+         return rv;
+      }
+
+      public static bool try_convert_args<T1, T2, T3, T4>(object[] args, out T1 arg1, out T2 arg2, out T3 arg3, out T4 arg4) {
+         if (args == null || args.Length != 4) {
+            arg1 = default;
+            arg2 = default;
+            arg3 = default;
+            arg4 = default;
+            return false;
+         }
+         bool rv = try_convert(args[0], out arg1);
+         rv |= try_convert(args[1], out arg2);
+         rv |= try_convert(args[2], out arg3);
+         rv |= try_convert(args[3], out arg4);
+         return rv;
+      }
    }
 }

src/client/spark/core/Settings/UserPersistFactory.cs

@@ -12,6 +12,9 @@ using bts.api.persistence;
 
 namespace mbts.ui.settings
 {
+   //
+   // This class is used for tools like SettingsManager.exe
+   // 
    [Export(typeof(IUserPersistFactory))]
    class UISettingsFactory : IUserPersistFactory
    {
@@ -34,7 +37,7 @@ namespace mbts.ui.settings
 
       public IUserPersist get_persist_for(string name) {
          var user = _users.Result.FirstOrDefault(u => u.Login == name);
-         return new UserUISettings(user.Id, _persist);
+         return new UserUISettings(user.Id, _persist, null);
       }
    }
 }

src/client/spark/core/ShellInterface/UISettings.cs

@@ -10,6 +10,7 @@ using bts.api.core;
 using bts.api.persistence;
 using System.Text.RegularExpressions;
 using System.Reactive.Linq;
+using bts.spark;
 
 namespace mbts.persist
 {
@@ -18,11 +19,13 @@ namespace mbts.persist
       protected abstract string user();
       string uns(string ns) { return $"{user()}#{ns}"; }
       PersistenceService _persist;
+      ErrorReporter _errors;   
 
       private const string _settings_change_base = "/ui/settingschange/";
 
-      public UISettingsBase(PersistenceService persist) {
+      public UISettingsBase(PersistenceService persist, ErrorReporter errors) {
          _persist = persist;
+         _errors = errors;
       }
 
 
@@ -50,7 +53,7 @@ namespace mbts.persist
             Ns = uns(ns),
             Key = { key }
          });
-         check_error(ret.value.Result, ns, key, out bool empty);
+         check_error(ret, ns, key, out bool empty);
          if (empty) return default(T);
          return deserialize<T>(ret.value.Record.Single().Value);
       }
@@ -67,20 +70,28 @@ namespace mbts.persist
          return ProtoBuf.Serializer.DeserializeWithLengthPrefix<T>(stream, ProtoBuf.PrefixStyle.Fixed32);
       }
 
-      private void check_error(RetrieveResponse.Types.Result result, string ns, string key, out bool empty) {
-         switch (result) {
-            case RetrieveResponse.Types.Result.EmptyNs:
-            case RetrieveResponse.Types.Result.NoSuchNs:
-            case RetrieveResponse.Types.Result.NoSuchKey:
-               empty = true;
-               return;
-            case RetrieveResponse.Types.Result.EmptyKey:
-            case RetrieveResponse.Types.Result.DuplicateKey:
-               throw new ArgumentException($"Invalid Key {result} '{key}'");
-            default:
-            case RetrieveResponse.Types.Result.Ok:
-               empty = false;
-               return;
+      private void check_error(Result<RetrieveResponse> result, string ns, string key, out bool empty) {
+         if (result.success) {
+            switch (result.value.Result) {
+               case RetrieveResponse.Types.Result.EmptyNs:
+               case RetrieveResponse.Types.Result.NoSuchNs:
+               case RetrieveResponse.Types.Result.NoSuchKey:
+                  empty = true;
+                  return;
+               case RetrieveResponse.Types.Result.EmptyKey:
+               case RetrieveResponse.Types.Result.DuplicateKey:
+                  _errors?.report_error($"Invalid Key {result} '{key}'", "Requested Invalid Settings Key", System.Windows.MessageBoxImage.Information);
+                  empty = true;
+                  return;
+               default:
+               case RetrieveResponse.Types.Result.Ok:
+                  empty = false;
+                  return;
+            }
+         }
+         else {
+            _errors?.report_error($"There was an error communicating with the settings server: '{result.error_message}'", "Failed to retrieve settings from the server");
+            empty = true;
          }
       }
 
@@ -90,7 +101,7 @@ namespace mbts.persist
             new RetrieveAllRequest() {
                Ns = uns(ns)
             });
-         check_error(results.value.Result, ns, "", out bool empty);
+         check_error(results, ns, "", out bool empty);
          if (empty) return Enumerable.Empty<PersistResult<T>>();
          return results.value.Record
             .Where(r => re.IsMatch(r.Key))
@@ -131,7 +142,7 @@ namespace mbts.persist
       protected override string user() { return "all_users"; }
 
       [ImportingConstructor]
-      public UISettings([Import("settings")]PersistenceService p) : base(p) { }
+      public UISettings([Import("settings")]PersistenceService p, ErrorReporter err) : base(p,err) { }
    }
 
    [Export(typeof(IUserPersist))]
@@ -140,8 +151,8 @@ namespace mbts.persist
       string _user;
 
       [ImportingConstructor]
-      public UserUISettings([Import("userid")]uint user, [Import("settings")]PersistenceService persist)
-         : base(persist) {
+      public UserUISettings([Import("userid")]uint user, [Import("settings")]PersistenceService persist, ErrorReporter err)
+         : base(persist,err) {
          _user = $"User {user}";
       }
 

src/client/spark/core/Utility/AnonymousEqualityComparer.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 
 namespace mbts.utils {
    public static class EqualityComparer {
+      const int _hash_seed = 63607, _hash_multiplier = 6451;
+
       public static IEqualityComparer<T> Create<T>(Func<T, T, bool> equals) =>
          new AnonymousEqualityComparer<T>(equals);
 
@@ -28,6 +30,31 @@ namespace mbts.utils {
          y != null &&
          non_null_equals(x, y);
 
+      public static int aggregate_hash(int item1_hash, int item2_hash, int item3_hash) {
+         int rv = _hash_seed;
+         unchecked {
+            _accumulate_hash(ref rv, ref item1_hash);
+            _accumulate_hash(ref rv, ref item2_hash);
+            _accumulate_hash(ref rv, ref item3_hash);
+         }
+         return rv;
+      }
+
+      // Note: be wary of the performance cost this method may have, as frequently creating large arrays can be expensive.
+      // If you wish to avoid this cost, consider making an overload like the method above, with the appropriate number of item-hash arguments
+      public static int aggregate_hash(params int[] item_hashes) {
+         int hash = _hash_seed;
+         unchecked {
+            foreach (int item_hash in item_hashes)
+               hash = hash * _hash_multiplier + item_hash;
+         }
+         return hash;
+      }
+
+      // WARNING: be sure to call this within in an unchecked scope
+      static void _accumulate_hash(ref int aggregate_hash, ref int item_hash) =>
+         aggregate_hash = aggregate_hash * _hash_multiplier + item_hash;
+
       private class AnonymousEqualityComparer<T> : IEqualityComparer<T> {
          readonly Func<T, T, bool> _equals;
          readonly Func<T, int> _get_hash_code;

src/client/spark/core/Utility/ObservableDemuxer.cs

@@ -2,9 +2,9 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
+using System.Threading;
 
 namespace mbts.utils {
    interface IObservableDemuxer<TKey, in TInput, out TOutput> : IObserver<TInput> {
@@ -89,21 +89,17 @@ namespace mbts.utils {
          _group_key = group_key;
       }
 
-      public void OnCompleted() { }
-      public void OnError(Exception error) { }
       public IObservable<ITableUpdateTransform<T, TKey>> subscribe(TGroupKey group_key) =>
          Observable.Create<ITableUpdateTransform<T, TKey>>(o => {
             var data = _map.GetOrAdd(group_key, gk => new Data());
-            lock (data) {
-               var current = data.current;
-               if (current.state.Count > 0) {
-                  var state_clone = current.state.ToDictionary();
-                  o.OnNext(new TableUpdateTransform<T, TKey>(state_clone, state_clone.Values.ToList(), new List<T>(0)));
-               }
+            using (data.read()) {
+               o.OnNext(data.current.as_snapshot());
+               return data.subject.Subscribe(o);
             }
-            return data.subject.Subscribe(o);
          });
 
+      public void OnCompleted() { }
+      public void OnError(Exception error) { }
       public void OnNext(TableUpdate<T, TKey> table) {
          var changes = new Dictionary<TGroupKey, ChangeSet>();
          foreach (T value in table.added)
@@ -116,16 +112,29 @@ namespace mbts.utils {
       }
 
       Data _update(Data data, ChangeSet changes) {
-         lock (data) {
-            data.current = data.current.update(changes.removed, changes.added, _key);
-            data.subject.OnNext(data.current);
-         }
+         using (data.write())
+            data.subject.OnNext(data.current = data.current.update(changes.removed, changes.added, _key));
          return data;
       }
 
       class Data {
+         int _n_read_ops, _n_write_ops;
          public readonly Subject<TableUpdateTransform<T, TKey>> subject = new Subject<TableUpdateTransform<T, TKey>>();
          public TableUpdateTransform<T, TKey> current = new TableUpdateTransform<T, TKey>();
+
+         public IDisposable read() {
+            while (_n_write_ops > 0)
+               Thread.Yield();
+            Interlocked.Increment(ref _n_read_ops);
+            return Disposable.Create(() => Interlocked.Decrement(ref _n_read_ops));
+         }
+
+         public IDisposable write() {
+            while (_n_read_ops > 0)
+               Thread.Yield();
+            Interlocked.Increment(ref _n_write_ops);
+            return Disposable.Create(() => Interlocked.Decrement(ref _n_write_ops));
+         }
       }
 
       // [John]I prefer this class over anonymous tuples bc it is easy to mix up Item1/Item2

src/client/spark/core/Utility/TableUpdateTransform.cs

@@ -7,12 +7,30 @@ using System.Linq;
 using System.Reactive.Linq;
 
 namespace mbts.utils {
+   interface IIncrementalUpdate<T, TKey> where TKey : IEquatable<TKey> {
+      IReadOnlyDictionary<TKey, T> added { get; }
+      IReadOnlyDictionary<TKey, T> removed { get; }
+   }
+
    interface ITableUpdateTransform<T, TKey> where TKey : IEquatable<TKey> {
       IReadOnlyDictionary<TKey, T> state { get; }
       IReadOnlyList<T> added { get; }
       IReadOnlyList<T> removed { get; }
    }
 
+   class IncrementalUpdate<T, TKey> : IIncrementalUpdate<T, TKey> where TKey : IEquatable<TKey> {
+      public IncrementalUpdate()
+         : this(new Dictionary<TKey, T>(0), new Dictionary<TKey, T>(0)) { }
+
+      public IncrementalUpdate(IReadOnlyDictionary<TKey, T> added, IReadOnlyDictionary<TKey, T> removed) {
+         this.added = added;
+         this.removed = removed;
+      }
+
+      public IReadOnlyDictionary<TKey, T> added { get; }
+      public IReadOnlyDictionary<TKey, T> removed { get; }
+   }
+
    class TableUpdateTransform<T, TKey> : ITableUpdateTransform<T, TKey> where TKey : IEquatable<TKey> {
       readonly Dictionary<TKey, T> _state;
       readonly IReadOnlyList<T> _added, _removed;
@@ -44,6 +62,18 @@ namespace mbts.utils {
             table._state.Add(key(item), item);
          return table;
       }
+
+      public TableUpdateTransform<T, TKey> update(IIncrementalUpdate<T, TKey> update, Func<T, TKey> key) {
+         var table = new TableUpdateTransform<T, TKey>(new Dictionary<TKey, T>(_state), added, removed);
+         foreach (var k in update.removed.Keys)
+            table._state.Remove(k);
+         foreach (var kv in update.added)
+            table._state.Add(kv.Key, kv.Value);
+         return table;
+      }
+
+      internal TableUpdateTransform<T, TKey> as_snapshot() =>
+         new TableUpdateTransform<T, TKey>(_state, _state.Values.ToList(), new T[0]);
    }
 
    [Browsable(false)]
@@ -58,6 +88,15 @@ namespace mbts.utils {
          .Select(u => new FilteredTableUpdateTransform<T, TKey>(u, predicate))
          .Where(u => u.added.Count > 0 || u.removed.Count > 0);
 
+      /// <summary>
+      /// Makes a 1:1 conversion to an IncrementalUpdate sequence of TResult (TKey remains the same).
+      /// </summary>
+      public static IObservable<IIncrementalUpdate<TResult, TKey>> convert<T, TKey, TResult>(this IObservable<IIncrementalUpdate<T, TKey>> source, Func<T, TResult> selector)
+         where TKey : IEquatable<TKey> =>
+         source.Select(update => new IncrementalUpdate<TResult, TKey>(
+            update.added.ToDictionary(kv => kv.Key, kv => selector(kv.Value)),
+            update.removed.ToDictionary(kv => kv.Key, kv => selector(kv.Value))));
+
       /// <summary>
       /// Converts sequence to show incremental changes with respect to the [TResult] value returned by result_selector.
       /// </summary>
@@ -69,6 +108,33 @@ namespace mbts.utils {
          source.Scan(new PivotTableUpdateTransform<T, TKey, TResult, TResultKey>(selector, result_key, key),
             (pivot, table) => pivot.update(table));
 
+      /// <summary>
+      /// Converts sequence to show incremental changes with respect to the [TResult] value returned by result_selector.
+      /// </summary>
+      public static IObservable<IIncrementalUpdate<TResult, TResultKey>> with_respect_to<T, TKey, TResult, TResultKey>(
+         this IObservable<IIncrementalUpdate<T, TKey>> source, Func<T, TResult> selector, Func<TResult, TResultKey> result_key, Func<T, TKey> key)
+         where TKey : IEquatable<TKey>
+         where TResultKey : IEquatable<TResultKey> =>
+         //
+         source.Scan(new PivotIncrementalUpdate<T, TKey, TResult, TResultKey>(selector, result_key, key),
+            (pivot, table) => pivot.update(table));
+
+      /// <summary>
+      /// Uses a Scan operator to accumulate state in the resulting ITableUpdateTransform sequence.
+      /// </summary>
+      public static IObservable<ITableUpdateTransform<T, TKey>> table<T, TKey>(this IObservable<IIncrementalUpdate<T, TKey>> source, Func<T, TKey> key) where TKey : IEquatable<TKey> =>
+         source.Scan(
+           new TableUpdateTransform<T, TKey>(),
+           (table, update) => table.update(update, key));
+
+      /// <summary>
+      /// Filters the incremental added/removed lists by a predicate.  Observers are only notified when the filtered added/removed lists have elements.
+      /// </summary>
+      public static IObservable<IIncrementalUpdate<T, TKey>> filter<T, TKey>(this IObservable<IIncrementalUpdate<T, TKey>> source, Func<T, bool> predicate)
+         where TKey : IEquatable<TKey> => source
+         .Select(u => new IncrementalUpdate<T, TKey>(u.added.Where(kv => predicate(kv.Value)).ToDictionary(), u.removed.Where(kv => predicate(kv.Value)).ToDictionary()))
+         .Where(u => u.added.Count > 0 || u.removed.Count > 0);
+
       class FilteredTableUpdateTransform<T, TKey> : ITableUpdateTransform<T, TKey> where TKey : IEquatable<TKey> {
          internal FilteredTableUpdateTransform(ITableUpdateTransform<T, TKey> source, Func<T, bool> predicate) {
             state = source.state;
@@ -81,6 +147,57 @@ namespace mbts.utils {
          public IReadOnlyList<T> removed { get; }
       }
 
+      class PivotIncrementalUpdate<T, TKey, TResult, TResultKey> : IIncrementalUpdate<TResult, TResultKey> where TKey : IEquatable<TKey> where TResultKey : IEquatable<TResultKey> {
+         readonly Dictionary<TResultKey, TResult> _state;
+         readonly SetMap<TResultKey, TKey> _key_map;
+         readonly Func<T, TResult> _selector;
+         readonly Func<TResult, TResultKey> _result_key;
+         readonly Func<T, TKey> _key;
+
+         internal PivotIncrementalUpdate(Func<T, TResult> selector, Func<TResult, TResultKey> result_key, Func<T, TKey> key) :
+            this(new Dictionary<TResultKey, TResult>(), new Dictionary<TResultKey, TResult>(0), new Dictionary<TResultKey, TResult>(0), new SetMap<TResultKey, TKey>(), selector, result_key, key) { }
+
+         PivotIncrementalUpdate(Dictionary<TResultKey, TResult> state, IReadOnlyDictionary<TResultKey, TResult> added, IReadOnlyDictionary<TResultKey, TResult> removed,
+            SetMap<TResultKey, TKey> key_map, Func<T, TResult> selector, Func<TResult, TResultKey> result_key, Func<T, TKey> key) {
+            //
+            _state = state;
+            this.added = added;
+            this.removed = removed;
+            _key_map = key_map;
+            _selector = selector;
+            _result_key = result_key;
+            _key = key;
+         }
+
+         public IReadOnlyDictionary<TResultKey, TResult> state => _state;
+         public IReadOnlyDictionary<TResultKey, TResult> added { get; }
+         public IReadOnlyDictionary<TResultKey, TResult> removed { get; }
+
+         public PivotIncrementalUpdate<T, TKey, TResult, TResultKey> update(IIncrementalUpdate<T, TKey> table) {
+            Dictionary<TResultKey, TResult> removed = new Dictionary<TResultKey, TResult>(), added = new Dictionary<TResultKey, TResult>();
+            var state_clone = new Dictionary<TResultKey, TResult>(_state);
+            foreach (var kv in table.removed) {
+               var result = _selector(kv.Value);
+               var rkey = _result_key(result);
+               if (_key_map.removes_key(rkey, kv.Key))
+                  removed.Add(rkey, result);
+            }
+            foreach (var kv in table.added) {
+               var result = _selector(kv.Value);
+               var rkey = _result_key(result);
+               if (_key_map.adds_key(rkey, kv.Key)) {
+                  if (!removed.Remove(rkey))
+                     added.Add(rkey, result);
+               }
+            }
+            foreach (var k in removed.Keys)
+               state_clone.Remove(k);
+            foreach (var kv in added)
+               state_clone.Add(kv.Key, kv.Value);
+            return new PivotIncrementalUpdate<T, TKey, TResult, TResultKey>(state_clone, added, removed, _key_map, _selector, _result_key, _key);
+         }
+      }
+
       class PivotTableUpdateTransform<T, TKey, TResult, TResultKey> : ITableUpdateTransform<TResult, TResultKey> where TKey : IEquatable<TKey> where TResultKey : IEquatable<TResultKey> {
          readonly Dictionary<TResultKey, TResult> _state;
          readonly SetMap<TResultKey, TKey> _key_map;

src/client/spark/core/Utility/ViewModelBase.cs

@@ -471,7 +471,7 @@ namespace mbts.ui.shell
       protected Property<T> backing<T, TData>(string name, IObservable<TData> source, Func<TData, T> select, T default_value = default) {
          if (_observable_properties == null) _observable_properties = new List<IDisposable>();
          var prop = new ObservablePropertySink<T>(this, name, default_value);
-         _observable_properties.Add(source.ObserveOnDispatcher().Subscribe(d => prop.set(select(d))));
+         _observable_properties.Add(source.OnDispatcher().Subscribe(d => prop.set(select(d))));
          return prop;
       }
 
@@ -526,8 +526,8 @@ namespace mbts.ui.shell
       protected SelectorProperty<T> backing<T>(string name, IObservable<IEnumerable<T>> items, IObservable<InlineUserProperty<T>> desired_item, Func<T> select_default, Func<T, T, bool> items_match, IReadOnlyList<PropertyValidation<T>> validation_steps) {
          if (_observable_properties == null) _observable_properties = new List<IDisposable>();
          var prop = new SelectorProperty<T>(this, name, select_default, items_match, validation_steps);
-         _observable_properties.Add(items.ObserveOnDispatcher().Subscribe(prop));
-         _observable_properties.Add(desired_item.ObserveOnDispatcher().Subscribe(prop));
+         _observable_properties.Add(items.OnDispatcher().Subscribe(prop));
+         _observable_properties.Add(desired_item.OnDispatcher().Subscribe(prop));
          return prop;
       }
 

src/client/spark/view/Controls/Badge.cs

@@ -1,141 +1,220 @@
-using mbts.spark;
-using mbts.ui.extensions;
+using bts.api;
+using mbts.spark;
+using mbts.ui.utility.text;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Globalization;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Input;
+using System.Windows.Data;
 using System.Windows.Media;
-using static mbts.config.Configuration;
+using FontFamily = System.Windows.Media.FontFamily;
 
 namespace mbts.ui.controls {
-   public class Badge: Control {
-      readonly static double _dpi = get<bts.config.System>().dpi_ratio;
+   public class Badge : Control {
+      public const double LINE_SPACING = 1;
+      // Storing the defaults here for readability
+      // Warning: these properties are used to calculate the ladder's row_height. Please change the values below if you want to change properties that affect the layout.
+      // ** - value is not the actual PropertyMetadata.DefaultValue
+      public static readonly Thickness
+         DefaultMargin = new Thickness(4, 2, 4, 2), // **
+         DefaultPadding = new Thickness(1),
+         DefaultBorderThickness = new Thickness(2);
+      public static readonly double
+         DefaultCornerRadius = 1,
+         DefaultFontSize = 10,
+         DefaultWidth = 63; // **
+      public static readonly FontFamily DefaultFontFamily = new FontFamily("Consolas");
+
+      readonly GlyphContentRect _gcr = new GlyphContentRect();
+      Brush _background, _foreground, _border_brush;
 
-      Typeface _face;
-      FormattedText _center_text;
-      FormattedText _top_text;
-      FormattedText _bottom_text;
       static Badge() {
          DefaultStyleKeyProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(typeof(Badge)));
-         WidthProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(15.0));
-         HeightProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(10.0));
-         FontSizeProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.AffectsRender /*| FrameworkPropertyMetadataOptions.AffectsMeasure*/, update_text));
-         ForegroundProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(Brushes.White, update_text));
-         BackgroundProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(Brushes.Transparent, FrameworkPropertyMetadataOptions.AffectsRender));
-         BorderThicknessProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(new Thickness(1)));
-         BorderBrushProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(Brushes.Black));
-         FontFamilyProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(new FontFamily("Consolas"), FrameworkPropertyMetadataOptions.AffectsRender /*| FrameworkPropertyMetadataOptions.AffectsMeasure*/, update_text));
-
-         //TextProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure, update_text));
-         //TopTextProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure, update_text));
-         //BottomTextProperty.OverrideMetadata(typeof(Badge), new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure, update_text));
+         // MinWidth
+         WPFHelper.override_metadata<double, Badge>(
+            MinWidthProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.min_width = v,
+            0);
+         // Width
+         WPFHelper.override_metadata<double, Badge>(
+            WidthProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.width = v,
+            double.NaN);
+         // Max Width
+         WPFHelper.override_metadata<double, Badge>(
+            MaxWidthProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.max_width = v,
+            double.MaxValue);
+         // Min Height
+         WPFHelper.override_metadata<double, Badge>(
+            MinHeightProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.min_height = v,
+            0);
+         // Height
+         WPFHelper.override_metadata<double, Badge>(
+            HeightProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.height = v,
+            double.NaN);
+         // Max Height
+         WPFHelper.override_metadata<double, Badge>(
+            MaxHeightProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.max_height = v,
+            double.MaxValue);
+         // FontSize
+         WPFHelper.override_metadata<double, Badge>(
+            FontSizeProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.font_size = v,
+            DefaultFontSize);
+         // Foreground
+         WPFHelper.override_metadata<Brush, Badge>(
+            ForegroundProperty,
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._foreground = v,
+            Brushes.White);
+         // Background
+         WPFHelper.override_metadata<Brush, Badge>(
+            BackgroundProperty,
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._background = v,
+            Brushes.Transparent);
+         // BorderThickness
+         WPFHelper.override_metadata<Thickness, Badge>(
+            BorderThicknessProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.border_thickness = v,
+            DefaultBorderThickness);
+         // BorderBrush
+         WPFHelper.override_metadata<Brush, Badge>(
+            BorderBrushProperty,
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._border_brush = v,
+            Brushes.Black);
+         // FontFamily
+         WPFHelper.override_metadata<FontFamily, Badge>(
+            FontFamilyProperty,
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.glyph_context = b._gcr.glyph_context.with(v),
+            DefaultFontFamily);
+         // HoriontalAlignment
+         WPFHelper.override_metadata<HorizontalAlignment, Badge>(
+            HorizontalAlignmentProperty,
+            FrameworkPropertyMetadataOptions.AffectsArrange |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (o, v) => o._gcr.horizontal_alignment = v,
+            HorizontalAlignment.Stretch);
+         // HoriontalContentAlignment
+         WPFHelper.override_metadata<HorizontalAlignment, Badge>(
+            HorizontalContentAlignmentProperty,
+            FrameworkPropertyMetadataOptions.AffectsArrange |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (o, v) => o._gcr.horizontal_content_alignment = v,
+            HorizontalAlignment.Center);
+         // VerticalAlignment
+         WPFHelper.override_metadata<VerticalAlignment, Badge>(
+            VerticalAlignmentProperty,
+            FrameworkPropertyMetadataOptions.AffectsArrange |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (o, v) => o._gcr.vertical_alignment = v,
+            VerticalAlignment.Center);
+         // VerticalContentAlignment
+         WPFHelper.override_metadata<VerticalAlignment, Badge>(
+            VerticalContentAlignmentProperty,
+            FrameworkPropertyMetadataOptions.AffectsArrange |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (o, v) => o._gcr.vertical_content_alignment = v,
+            VerticalAlignment.Center);
+         // Padding
+         WPFHelper.override_metadata<Thickness, Badge>(
+            PaddingProperty,
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (p, v) => p._gcr.padding = v,
+            DefaultPadding);
       }
 
-      public string Text {
-         get { return (string)GetValue(TextProperty); }
-         set { SetValue(TextProperty, value); }
-      }
-      public static readonly DependencyProperty TextProperty =
-          DependencyProperty.Register("Text", typeof(string), typeof(Badge), new PropertyMetadata(string.Empty, 
-             format_text((b,v) => b._center_text= v)));
-
-
-      public string TopText {
-         get { return (string)GetValue(TopTextProperty); }
-         set { SetValue(TopTextProperty, value); }
-      }
-      public static readonly DependencyProperty TopTextProperty =
-          DependencyProperty.Register(nameof(TopText), typeof(string), typeof(Badge), new PropertyMetadata(string.Empty,
-             format_text((b, v) => b._top_text = v)));
-
-      public string BottomText {
-         get { return (string)GetValue(BottomTextProperty); }
-         set { SetValue(BottomTextProperty, value); }
+      public Badge() {
+         _gcr.min_width = MinWidth;
+         _gcr.width = Width;
+         _gcr.max_width = MaxWidth;
+         _gcr.min_height = MinHeight;
+         _gcr.height = Height;
+         _gcr.max_height = Height;
+         _gcr.padding = Padding;
+         _gcr.border_thickness = BorderThickness;
+         _gcr.horizontal_alignment = HorizontalAlignment;
+         _gcr.horizontal_content_alignment = HorizontalContentAlignment;
+         _gcr.vertical_alignment = VerticalAlignment;
+         _gcr.vertical_content_alignment = VerticalContentAlignment;
+         _background = Background;
+         _foreground = Foreground;
+         _border_brush = BorderBrush;
+         _gcr.font_size = FontSize;
+         _gcr.text_lines = TextLines;
+         _gcr.glyph_context = GlyphContext.create(FontFamily, FontWeight);
       }
 
-      public static readonly DependencyProperty BottomTextProperty =
-          DependencyProperty.Register(nameof(BottomText), typeof(string), typeof(Badge), new PropertyMetadata(string.Empty, 
-             format_text((b,v)=>b._bottom_text=v)));
+      public static readonly DependencyProperty TextLinesProperty =
+         WPFHelper.create_dp<IReadOnlyList<string>, Badge>(
+            nameof(TextLines),
+            FrameworkPropertyMetadataOptions.AffectsMeasure |
+            FrameworkPropertyMetadataOptions.AffectsRender,
+            (b, v) => b._gcr.text_lines = v,
+            new string[0]);
+
+      public IReadOnlyList<string> TextLines {
+         get => GetValue(TextLinesProperty) as IReadOnlyList<string>;
+         set => SetValue(TextLinesProperty, value);
+      }
 
       public double CornerRadius {
          get { return (double)GetValue(CornerRadiusProperty); }
          set { SetValue(CornerRadiusProperty, value); }
       }
+
       public static readonly DependencyProperty CornerRadiusProperty =
-          DependencyProperty.Register("CornerRadius", typeof(double), typeof(Badge), new PropertyMetadata(3.0));
+         WPFHelper.create_dp<double, Badge>(nameof(CornerRadius), DefaultCornerRadius);
 
-      static PropertyChangedCallback format_text(Action<Badge,FormattedText> f) {
-         return (d, e) => {
-            Badge b = (Badge)d;
-            ensure_fontface(b);
-            string text = e.NewValue as string;
-            if (string.IsNullOrEmpty(text)) f(b, null);
-            f(b, new FormattedText(text,
-               System.Globalization.CultureInfo.CurrentCulture,
-               FlowDirection.LeftToRight,
-               b._face, b.FontSize, b.Foreground, _dpi));
-            b.InvalidateVisual();
-         };
+      protected override Size ArrangeOverride(Size finalSize) => finalSize;
+
+      protected override Size MeasureOverride(Size availableSize) {
+         _gcr.available_size = availableSize;
+         return _gcr.layout_size;
       }
-      static FormattedText format_text(Badge badge, DependencyProperty source) {
-         FormattedText result = null;
-         var value = badge.GetValue(source);
-         format_text((b, v) => result = v)(badge, new DependencyPropertyChangedEventArgs(source, value, value));
-         return result;
-      }
-
-      static void update_text(DependencyObject d, DependencyPropertyChangedEventArgs args) {
-         // Force formatted text regeneration when font/color changes
-         Badge badge = (Badge)d;
-         badge._face = null;
-         ensure_fontface(badge);
-         badge._center_text = format_text(badge, TextProperty);
-         badge._top_text = format_text(badge, TopTextProperty);
-         badge._bottom_text = format_text(badge, BottomTextProperty);
-      }
-
-      private static void ensure_fontface(Badge b) {
-         b._face = b._face ?? new Typeface(b.FontFamily, b.FontStyle, b.FontWeight, b.FontStretch);
-      }
-
-      //protected override Size MeasureOverride(Size availableSize) {
-      //   Double calc_height = 0.0;
-      //   Double calc_width = 0.0;
-      //   Size size = new Size(0, 0);
-
-      //   Size center_size = new Size(_center_text.Width, _center_text.Height);
-      //   Size top_size = new Size(_top_text.Width, _top_text.Height);
-      //   Size bottom_size = new Size(_bottom_text.Width, _bottom_text.Height);
-
-      //   calc_width = Math.Max(center_size.Width, top_size.Width);
-      //   calc_width = Math.Max(calc_width, bottom_size.Width);
-
-      //   calc_height += center_size.Height;
-      //   calc_height += top_size.Height;
-      //   calc_height += bottom_size.Height;
-
-      //   size.Width = calc_width;
-      //   size.Height = calc_height;
-
-      //   return size;
-
-      //}
 
       protected override void OnRender(DrawingContext dc) {
          base.OnRender(dc);
          double border_thickness = BorderThickness.Top;
          var pen = new Pen(BorderBrush, border_thickness);
-         dc.DrawRoundedRectangle(Background, pen, new Rect(0, 0 + border_thickness, ActualWidth, ActualHeight - 2 * border_thickness), CornerRadius, CornerRadius);
-         if (_center_text != null)
-            dc.DrawText(_center_text, new Point((ActualWidth-_center_text.Width)/2, (ActualHeight-_center_text.Height)/2));
-         if (_top_text != null)
-             dc.DrawText(_top_text, new Point(border_thickness, border_thickness));
-         if (_bottom_text != null)
-            dc.DrawText(_bottom_text, new Point(border_thickness, ActualHeight - _bottom_text.Height - border_thickness));
+         dc.DrawRoundedRectangle(Background, pen, new Rect(0, border_thickness, _gcr.layout_size.Width, _gcr.layout_size.Height), CornerRadius, CornerRadius);
+         var gr = _gcr.glyph_run;
+         if (gr != null)
+            dc.DrawGlyphRun(_foreground, gr);
       }
-   } 
+   }
+
+   class BadgeTextLinesConverter : IMultiValueConverter {
+      public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) {
+         if (ObjectHelper.try_convert_args(values, out Side side, out uint quantity, out uint filled, out mbts.spark.LadderSettings.BadgeStyle style))
+            return BadgeRender.format(side, quantity, filled, style);
+         else return new string[0];
+      }
+
+      public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) => throw new NotImplementedException();
+   }
 }

src/client/spark/view/Controls/CountDownTimer.cs

@@ -73,7 +73,7 @@ namespace mbts.ui.controls {
          Disposable.dispose(ref timer._trigger_sub);
          IObservable<object> newval = args.NewValue as IObservable<object>;
          if (newval != null) {
-            timer._trigger_sub = newval.ObserveOnDispatcher().Subscribe(timer.start);
+            timer._trigger_sub = newval.OnDispatcher().Subscribe(timer.start);
          }
       }
 

src/client/spark/view/Controls/DIYGrid/Columns/ColumnBase.cs

@@ -1,4 +1,5 @@
 using mbts.spark.filters;
+using System;
 using System.ComponentModel;
 using System.Windows;
 using System.Windows.Controls;
@@ -60,13 +61,19 @@ namespace mbts.ui.controls {
             WPFHelper.create_dp<ListSortDirection?, ColumnBase>(
                nameof(SortDirection), (o, v) => o.OnSortDirectionChanged(v));
 
-         public ListSortDirection? SortDirection { get => GetValue(SortDirectionProperty) as ListSortDirection?; set => SetValue(SortDirectionProperty, value); }
+         public ListSortDirection? SortDirection {
+            get => GetValue(SortDirectionProperty) as ListSortDirection?;
+            set => SetValue(SortDirectionProperty, value);
+         }
+
+         public event Action<ColumnBase, ListSortDirection?> sort_direction_changed;
 
          public string sort_member_path { get; set; }
          public double original_width { get; set; }
          public bool is_collapsed { get; set; }
 
-         protected virtual void OnSortDirectionChanged(ListSortDirection? new_value) { }
+         protected virtual void OnSortDirectionChanged(ListSortDirection? new_value) =>
+            sort_direction_changed?.Invoke(this, new_value);
       }
 
       internal abstract class ColumnBase<TColKey> : ColumnBase, IKeyedColumn<TColKey> {

src/client/spark/view/Controls/DataGridEx/Filters/VM/DiscreteValuesFilterVM.cs

@@ -49,7 +49,7 @@ namespace mbts.spark.filters {
       ) => new DynamicItemsFilter<TRow, TValue, TState>(items, get_row_val, get_state, load_state, prop_name, equality_comparer, comparer);
 
       public static IDataGridColumnPersistentFilter<TRow, TState> Create<TRow, TValue, TState>(
-        IObservable<(IReadOnlyList<TValue> added, IReadOnlyList<TValue> removed)> items,
+        IObservable<(IEnumerable<TValue> added, IEnumerable<TValue> removed)> items,
         Func<TRow, TValue> get_row_val,
         Func<ISet<TValue>, TState> get_state,
         Func<TState, IObservable<IEnumerable<TValue>>> load_state,
@@ -115,14 +115,14 @@ namespace mbts.spark.filters {
             IComparer<TValue> comparer = null
          ) : this(get_row_val, get_state, load_state, prop_name, equality_comparer, comparer) {
             //
-            _items_sub = items.ObserveOnDispatcher().Subscribe(new_items => {
+            _items_sub = items.OnDispatcher().Subscribe(new_items => {
                _items_set.SetItems(new_items.Concat(_selected_items_set));
                _unsorted_items.sync_with(_items_set);
             });
          }
  
          public DynamicItemsFilter(
-            IObservable<(IReadOnlyList<TValue> added, IReadOnlyList<TValue> removed)> items,
+            IObservable<(IEnumerable<TValue> added, IEnumerable<TValue> removed)> items,
             Func<TRow, TValue> get_row_val,
             Func<ISet<TValue>, TState> get_state,
             Func<TState, IObservable<IEnumerable<TValue>>> load_state,
@@ -131,7 +131,7 @@ namespace mbts.spark.filters {
             IComparer<TValue> comparer = null
          ) : this(get_row_val, get_state, load_state, prop_name, equality_comparer, comparer) {
             //
-            _items_sub = items.ObserveOnDispatcher().Subscribe(update => {
+            _items_sub = items.OnDispatcher().Subscribe(update => {
                foreach (var v in update.added)
                   _items_set.Add(v);
                foreach (var v in update.removed.Except(_selected_items_set))
@@ -182,7 +182,7 @@ namespace mbts.spark.filters {
 
          protected override void _load_state_internal(TState state) {
             Disposable.dispose(ref _desired_items_sub);
-            _desired_items_sub = _load_state(state).ObserveOnDispatcher().Subscribe(_on_desired_item);
+            _desired_items_sub = _load_state(state).OnDispatcher().Subscribe(_on_desired_item);
          }
 
          protected override void _apply() {

src/client/spark/view/Controls/DataGridEx/Filters/Views/TimeFilter.cs

@@ -54,8 +54,9 @@ namespace mbts.ui {
       public static TimeTextTuple FromTicks(long ticks) =>
          FromDateTime(new DateTime(ticks));
 
-      public static TimeTextTuple FromDateTime(DateTime date_time) =>
-         new TimeTextTuple(DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames[date_time.Month - 1], date_time.Day.ToString(), date_time.Year.ToString(), date_time.ToString("t"));
+      public static TimeTextTuple FromDateTime(DateTime date_time) => FromDateTime(date_time, "t");
+      public static TimeTextTuple FromDateTime(DateTime date_time, string time_format) =>
+         new TimeTextTuple(DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames[date_time.Month - 1], date_time.Day.ToString(), date_time.Year.ToString(), date_time.ToString(time_format));
 
       public TimeTextTuple(string month_text, string day_text, string year_text, string time_text) {
          _month_text = month_text;
@@ -107,14 +108,23 @@ namespace mbts.ui {
 
 
       static DateTime? _parse(string month_text, string day_text, string year_text, string time_text) {
-         DateTime? t = _parse(time_text);
+         TimeSpan? t = _parse_time(time_text);
          if (t.HasValue) {
             DateTime? d = _parse($"{month_text}/{day_text}/{year_text}");
-            if (d.HasValue) return d.Value.Date.AddDays(t.Value.TimeOfDay.TotalDays);
+            if (d.HasValue) return d.Value.Date.Add(t.Value);
          }
          return null;
       }
 
+      static TimeSpan? _parse_time(string text) {
+         DateTime? dt = _parse(text);
+         if (dt.HasValue) {
+            return dt.Value.TimeOfDay;
+         } else if (TimeSpan.TryParse(text, out TimeSpan result) && result < TimeSpan.FromDays(1)) {
+            return result;
+         } else return null;
+      }
+
       static DateTime? _parse(string text) {
          if (!string.IsNullOrEmpty(text) && DateTime.TryParse(text, out DateTime result))
             return result;

src/client/spark/view/Controls/DataGridEx/Filters/Views/TimeFilterControl.xaml

@@ -26,7 +26,7 @@
                 ItemTemplate="{StaticResource EnumDescriptionTemplate}"
                 SelectedItem="{Binding Mode, RelativeSource={RelativeSource TemplatedParent}}"
               />
-              <Grid x:Name="PeriodRoot" Grid.Row="1" Margin="0,6,0,0" IsEnabled="False">
+              <Grid x:Name="PeriodRoot" Grid.Row="1" Margin="24,6,0,0" IsEnabled="False">
                 <Grid.RowDefinitions>
                   <RowDefinition/>
                   <RowDefinition Height="4"/>

src/client/spark/view/Controls/DataGridEx/Filters/Views/TimeFilterControl.xaml.cs

@@ -73,8 +73,9 @@ namespace mbts.ui.controls {
    public enum TimeFilterMode {
       Anytime,
       Today,
+      [Description("Period:")]
       Period,
-      [Description("Glbx Open")]
+      [Description("Since Open")]
       CMEOpen
    }
 }

src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml

@@ -10,6 +10,7 @@
     <ResourceDictionary Source="/view/Controls/PriceEntryControl.xaml"/>
     <ResourceDictionary Source="/view/Controls/Popup/PopupControl.xaml"/>
     <ResourceDictionary Source="/view/Controls/Time/TimeSpanControl.xaml"/>
+    <ResourceDictionary Source="/view/Controls/Order/QuantityMeasureControl.xaml"/>
     <ResourceDictionary Source="/Modules/Spreader/ExecutionStrategyEditor.xaml"/>
   </ResourceDictionary.MergedDictionaries>
   <Style TargetType="uag:OrderDetailsPopupControl">
@@ -155,6 +156,186 @@
                       </Grid>
                     </DataTemplate>
                   </usp:OrderModificationTemplateSelector.TimeBoxOrderTemplate>
+                  <usp:OrderModificationTemplateSelector.TickOrderTemplate>
+                    <DataTemplate>
+                      <Grid>
+                        <Grid.RowDefinitions>
+                          <RowDefinition/>
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />                          
+                          <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <Grid.ColumnDefinitions>
+                          <ColumnDefinition Width="Auto"/>
+                          <ColumnDefinition Width="12"/>
+                          <ColumnDefinition/>
+                        </Grid.ColumnDefinitions>
+                        <TextBlock Grid.Row="1" VerticalAlignment="Center">Cross Thresh</TextBlock>
+                        <uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding cross_threshold}"/>
+                        
+                        <TextBlock Grid.Row="3" VerticalAlignment="Center">Cross Ticks</TextBlock>
+                        <c:TickUpDownUInt Grid.Row="3" Grid.Column="2" Value="{Binding cross_ticks}"/>
+                        <TextBlock Grid.Row="5" VerticalAlignment="Center">Max Chase Ticks</TextBlock>
+                        <c:TickUpDownUInt Grid.Row="5" Grid.Column="2" Value="{Binding max_chase_ticks}"/>
+                        <CheckBox Grid.Row="7" Grid.Column="2" VerticalAlignment="Center" Margin="0,0,0,0" IsChecked="{Binding detach_on_toward}">Detach on Toward</CheckBox>
+                        <TextBlock Grid.Row="9" VerticalAlignment="Center">Initial Tick Offset</TextBlock>
+                        <c:TickUpDownUInt Grid.Row="9" Grid.Column="2" Value="{Binding tick_offset_on_deploy}"/>
+                        <TextBlock Grid.Row="11">Child</TextBlock>
+                        <uag:OrderDetailsPopupControl
+                          Grid.Row="11" Grid.Column="2"
+                          IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
+                          ItemsSource="{Binding child_order_types}"
+                          SelectedItem="{Binding child_order}"
+                          HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
+                        />
+                      </Grid>
+                    </DataTemplate>
+                  </usp:OrderModificationTemplateSelector.TickOrderTemplate>   
+                  <usp:OrderModificationTemplateSelector.LeanOrderTemplate>
+                    <DataTemplate>
+                      <Grid>
+                        <Grid.RowDefinitions>
+                          <RowDefinition/>
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <Grid.ColumnDefinitions>
+                          <ColumnDefinition Width="Auto"/>
+                          <ColumnDefinition Width="12"/>
+                          <ColumnDefinition/>
+                        </Grid.ColumnDefinitions>
+                        <TextBlock Grid.Row="1" VerticalAlignment="Center">Cross Thresh</TextBlock>
+                        <uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding cross_threshold}"/>
+                        <TextBlock Grid.Row="3" VerticalAlignment="Center">Max Chase Ticks</TextBlock>
+                        <c:TickUpDownUInt Grid.Row="3" Grid.Column="2" Value="{Binding max_chase_ticks}"/>
+                        <TextBlock Grid.Row="5">Child</TextBlock>
+                        <uag:OrderDetailsPopupControl
+                          Grid.Row="5" Grid.Column="2"
+                          IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
+                          ItemsSource="{Binding child_order_types}"
+                          SelectedItem="{Binding child_order}"
+                          HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
+                        />
+                      </Grid>
+                    </DataTemplate>
+                  </usp:OrderModificationTemplateSelector.LeanOrderTemplate>  
+                  <usp:OrderModificationTemplateSelector.JoinOrderTemplate>
+                    <DataTemplate>
+                      <Grid>
+                        <Grid.RowDefinitions>
+                          <RowDefinition/>
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />                          
+                          <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <Grid.ColumnDefinitions>
+                          <ColumnDefinition Width="Auto"/>
+                          <ColumnDefinition Width="12"/>
+                          <ColumnDefinition/>
+                        </Grid.ColumnDefinitions>
+                        <TextBlock Grid.Row="1" VerticalAlignment="Center">Join Thresh</TextBlock>
+                        <uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding join_threshold}"/>                                                
+                        <CheckBox Grid.Row="3" Grid.Column="2" VerticalAlignment="Center" Margin="0,0,0,0" IsChecked="{Binding enable_hedge}">Enable Hedge</CheckBox>
+                        <TextBlock Grid.Row="5" VerticalAlignment="Center" IsEnabled="{Binding enable_hedge}" >Hedge Ticks</TextBlock>                                                
+                        <c:TickUpDownInt Grid.Row="5" Grid.Column="2" IsEnabled="{Binding enable_hedge}" Value="{Binding hedge_ticks}"/>
+                        <TextBlock Grid.Row="7">Hedge</TextBlock>
+                        <uag:OrderDetailsPopupControl
+                          Grid.Row="7" Grid.Column="2"
+                          IsEnabled="{Binding enable_hedge}"
+                          IsOpen="{Binding hedge_order.editable_properties_open, FallbackValue=False}"
+                          ItemsSource="{Binding hedge_order_types}"
+                          SelectedItem="{Binding hedge_order}"
+                          HasEditableProperties="{Binding hedge_order.has_editable_properties, FallbackValue=False}"
+                        />                        
+                        <TextBlock Grid.Row="9" VerticalAlignment="Center">Initial Tick Offset</TextBlock>
+                        <c:TickUpDownUInt Grid.Row="9" Grid.Column="2" Value="{Binding tick_offset_on_deploy}"/>
+                        <TextBlock Grid.Row="11">Child</TextBlock>
+                        <uag:OrderDetailsPopupControl
+                          Grid.Row="11" Grid.Column="2"
+                          IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
+                          ItemsSource="{Binding child_order_types}"
+                          SelectedItem="{Binding child_order}"
+                          HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
+                        />
+                      </Grid>
+                    </DataTemplate>
+                  </usp:OrderModificationTemplateSelector.JoinOrderTemplate>
+                  <usp:OrderModificationTemplateSelector.TopOrderTemplate>
+                    <DataTemplate>
+                      <Grid>
+                        <Grid.RowDefinitions>
+                          <RowDefinition/>
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition Height="4" />                          
+                          <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <Grid.ColumnDefinitions>
+                          <ColumnDefinition Width="Auto"/>
+                          <ColumnDefinition Width="12"/>
+                          <ColumnDefinition/>
+                        </Grid.ColumnDefinitions>
+                        <TextBlock Grid.Row="1" VerticalAlignment="Center">Top Thresh</TextBlock>
+                        <uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding top_threshold}"/>                                                
+                        <CheckBox Grid.Row="3" Grid.Column="2" VerticalAlignment="Center" Margin="0,0,0,0" IsChecked="{Binding enable_hedge}">Enable Hedge</CheckBox>
+                        <TextBlock Grid.Row="5" VerticalAlignment="Center" IsEnabled="{Binding enable_hedge}" >Hedge Ticks</TextBlock>                                                
+                        <c:TickUpDownInt Grid.Row="5" Grid.Column="2" IsEnabled="{Binding enable_hedge}" Value="{Binding hedge_ticks}"/>
+                        <TextBlock Grid.Row="7">Hedge</TextBlock>
+                        <uag:OrderDetailsPopupControl
+                          Grid.Row="7" Grid.Column="2"
+                          IsEnabled="{Binding enable_hedge}"
+                          IsOpen="{Binding hedge_order.editable_properties_open, FallbackValue=False}"
+                          ItemsSource="{Binding hedge_order_types}"
+                          SelectedItem="{Binding hedge_order}"
+                          HasEditableProperties="{Binding hedge_order.has_editable_properties, FallbackValue=False}"
+                        />                        
+                        <TextBlock Grid.Row="9" VerticalAlignment="Center">Watch Levels</TextBlock>
+                        <c:TickUpDownUInt Grid.Row="9" Grid.Column="2" Value="{Binding watch_level_tick_offset}"/>
+                        <TextBlock Grid.Row="11">Child</TextBlock>
+                        <uag:OrderDetailsPopupControl
+                          Grid.Row="11" Grid.Column="2"
+                          IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
+                          ItemsSource="{Binding child_order_types}"
+                          SelectedItem="{Binding child_order}"
+                          HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
+                        />
+                      </Grid>
+                    </DataTemplate>
+                  </usp:OrderModificationTemplateSelector.TopOrderTemplate>                                                                                                                              
                   <usp:OrderModificationTemplateSelector.IcebergOrderTemplate>
                     <DataTemplate>
                       <Grid>
@@ -180,21 +361,31 @@
                         />
                       </Grid>
                     </DataTemplate>
-                  </usp:OrderModificationTemplateSelector.IcebergOrderTemplate>
+                  </usp:OrderModificationTemplateSelector.IcebergOrderTemplate>                
                   <usp:OrderModificationTemplateSelector.SpreaderTemplate>
                     <DataTemplate>
-                      <usp:ExecutionStrategyEditor
-                        HorizontalAlignment="Stretch" Margin="6"
-                        DataContext="{Binding strategy_editor}"
-                        SyntheticName="{Binding name}"
-                        IsNew="{Binding is_new}"
-                        IsNewLegPopupOpen="{Binding is_new_leg_popup_open}"
-                        PriceCalc="{Binding price_calc}"
-                        ParameterRows="{Binding rows}"
-                        LegTuples="{Binding leg_tuples}"
-                        RemoveLegCommand="{Binding remove_leg}"
-                        ContractPickerModel="{Binding contract_picker_model}"
-                      />
+                      <Grid>
+                        <Grid.RowDefinitions>
+                          <RowDefinition Height="Auto"/>
+                          <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <usp:ExecutionStrategyEditor
+                          Margin="6"
+                          HorizontalAlignment="Stretch"
+                          DataContext="{Binding strategy_editor}"
+                          SyntheticName="{Binding name}"
+                          TickFactors="{Binding tick_factors}"
+                          AvailableTickFactors="{Binding available_tick_factors_view}"
+                          IsNew="False"
+                          IsNewLegPopupOpen="{Binding is_new_leg_popup_open}"
+                          PriceCalc="{Binding price_calc}"
+                          ParameterRows="{Binding rows}"
+                          LegTuples="{Binding leg_tuples}"
+                          RemoveLegCommand="{Binding remove_leg}"
+                          ContractPickerModel="{Binding contract_picker_model}"
+                        />
+                        <c:DialogSkirt Grid.Row="1" Margin="-4" RightItems="{Binding skirt_items}"/>
+                      </Grid>
                     </DataTemplate>
                   </usp:OrderModificationTemplateSelector.SpreaderTemplate>
                 </usp:OrderModificationTemplateSelector>

src/client/spark/view/Controls/Order/OrderTypeItem.xaml

@@ -15,7 +15,7 @@
                 <ColumnDefinition Width="Auto"/>
                 <ColumnDefinition/>
               </Grid.ColumnDefinitions>
-              <c:Badge Background="{Binding Metadata, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource OrderTypeBrushConverter}}" Width="15" Height="10" HorizontalAlignment="Left" />
+              <c:Badge Background="{Binding Metadata, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource OrderTypeBrushConverter}}" BorderThickness="1" Width="15" Height="10" HorizontalAlignment="Left" />
               <TextBlock Text="{Binding OrderType, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource OrderTypeDisplayTextConverter}}" Margin="20,0,0,0" HorizontalAlignment="Left" />
             </Grid>
           </Border>

src/client/spark/view/Controls/PriceEntryControl.xaml

@@ -28,7 +28,14 @@
         BorderBrush="{TemplateBinding BorderBrush}"
         BorderThickness="{TemplateBinding BorderThickness}"
         Text="{Binding Value, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource TickDisplayTwoWayConverter}, Mode=TwoWay}"
-      />
+      >
+        <TextBox.CommandBindings>
+          <CommandBinding Command="{x:Static u:TextBoxBehavior.SelectAllCommand}" Executed="{x:Static u:TextBoxBehavior.SelectAllCommandExecutedHandler}"/>
+        </TextBox.CommandBindings>
+        <TextBox.InputBindings>
+          <MouseBinding MouseAction="LeftDoubleClick" Command="{x:Static u:TextBoxBehavior.SelectAllCommand}"/>
+        </TextBox.InputBindings>
+      </TextBox>
     </c:TickUpDown>
   </ControlTemplate>
   <Style TargetType="usp:PriceEntryControl">

src/client/spark/view/Controls/PriceEntryControl.xaml.cs

@@ -47,24 +47,30 @@ namespace mbts.ui.spark {
       #endregion
 
       TextBox _text;
-      IDisposable _text_input_hook;
 
       public PriceEntryControl() {
          TickUpCommand = new DelegateCommand(_tick_up);
          TickDownCommand = new DelegateCommand(_tick_down);
       }
 
+      IDisposable _keyboard_focus_sub;
+      bool _has_keyboard_focus;
+
       public override void OnApplyTemplate() {
+         Disposable.dispose(ref _keyboard_focus_sub);
          _text = this.assert_template_child<TextBox>("_text");
-         Disposable.dispose(ref _text_input_hook);
-         _text_input_hook = _text.SubscribePreviewTextInput((s, e) => e.Handled = !RegexFilters.PriceInput.IsMatch(_text.PeekText(e)));
+         _keyboard_focus_sub = _text.SubscribeKeyboardFocus(val => _has_keyboard_focus = val);
          _update_text_binding();
       }
 
       void _tick_up() {
+         if (_has_keyboard_focus) {
+            _text.GetBindingExpression(TextBox.TextProperty)?.UpdateSource();
+         }
          double v = Value;
-         if (double.IsNaN(v)) SetCurrentValue(ValueProperty, TickDefaultValue);
-         else {
+         if (double.IsNaN(v)) {
+            SetCurrentValue(ValueProperty, TickDefaultValue);
+         } else {
             var spec = ContractSpec;
             if (spec.HasValue) SetCurrentValue(ValueProperty, spec.Value.tickup(v));
             else SetCurrentValue(ValueProperty, TickDefaultValue);
@@ -72,9 +78,13 @@ namespace mbts.ui.spark {
       }
 
       void _tick_down() {
+         if (_has_keyboard_focus) {
+            _text.GetBindingExpression(TextBox.TextProperty)?.UpdateSource();
+         }
          double v = Value;
-         if (double.IsNaN(v)) SetCurrentValue(ValueProperty, TickDefaultValue);
-         else {
+         if (double.IsNaN(v)) {
+            SetCurrentValue(ValueProperty, TickDefaultValue);
+         } else {
             var spec = ContractSpec;
             if (spec.HasValue) SetCurrentValue(ValueProperty, spec.Value.tickdown(v));
             else SetCurrentValue(ValueProperty, TickDefaultValue);

src/client/spark/view/Controls/TickUpDown/TickUpDown.xaml.cs

@@ -23,38 +23,42 @@ namespace mbts.ui.controls {
       }
 
       protected override void OnPreviewKeyDown(KeyEventArgs e) {
-         switch (Keyboard.Modifiers) {
-            case ModifierKeys.None: {
-                  switch (e.Key) {
-                     case Key.Up:
-                        TickUpCommand.TryExecuteIfCan(TickUpParameter);
-                        e.Handled = true;
-                        break;
-                     case Key.Down:
-                        TickDownCommand.TryExecuteIfCan(TickDownParameter);
-                        e.Handled = true;
-                        break;
+         if (EnableArrowKeyTick) {
+            switch (Keyboard.Modifiers) {
+               case ModifierKeys.None: {
+                     switch (e.Key) {
+                        case Key.Up:
+                           TickUpCommand.TryExecuteIfCan(TickUpParameter);
+                           e.Handled = true;
+                           break;
+                        case Key.Down:
+                           TickDownCommand.TryExecuteIfCan(TickDownParameter);
+                           e.Handled = true;
+                           break;
+                     }
                   }
-               }
-               break;
-            case ModifierKeys.Alt: {
-                  // see: https://stackoverflow.com/questions/3099472/previewkeydown-is-not-seeing-alt-modifiers
-                  switch (e.SystemKey) {
-                     case Key.Up:
-                        TickUpCommand.TryExecuteIfCan(TickUpAltParameter);
-                        e.Handled = true;
-                        break;
-                     case Key.Down:
-                        TickDownCommand.TryExecuteIfCan(TickDownAltParameter);
-                        e.Handled = true;
-                        break;
+                  break;
+               case ModifierKeys.Alt: {
+                     // see: https://stackoverflow.com/questions/3099472/previewkeydown-is-not-seeing-alt-modifiers
+                     switch (e.SystemKey) {
+                        case Key.Up:
+                           TickUpCommand.TryExecuteIfCan(TickUpAltParameter);
+                           e.Handled = true;
+                           break;
+                        case Key.Down:
+                           TickDownCommand.TryExecuteIfCan(TickDownAltParameter);
+                           e.Handled = true;
+                           break;
+                     }
                   }
-               }
-               break;
+                  break;
+            }
          }
          base.OnPreviewKeyDown(e);
       }
 
+      public bool EnableArrowKeyTick { get; set; } = true;
+
       #region TickCommand
       public ICommand TickCommand {
          get { return (ICommand)GetValue(TickCommandProperty); }

src/client/spark/view/Controls/Time/DateTimePicker.xaml

@@ -31,8 +31,14 @@
               <ColumnDefinition Width="Auto"/>
               <ColumnDefinition/>
             </Grid.ColumnDefinitions>
-            <c:TickUpDown x:Name="PART_time_tick" Grid.Column="0" MinWidth="85" HorizontalAlignment="Stretch">
-              <TextBox x:Name="PART_time_text" Height="20" u:TextBoxBehavior.EnableArrowKeyTraverse="True" u:Behavior.DisablePaste="True"/>
+            <c:TickUpDown x:Name="PART_time_tick" Grid.Column="0" MinWidth="85" HorizontalAlignment="Stretch" EnableArrowKeyTick="False">
+              <TextBox x:Name="PART_time_text" Height="20" u:TextBoxBehavior.EnableArrowKeyTraverse="True" u:Behavior.DisablePaste="True">
+                <TextBox.InputBindings>
+                  <KeyBinding Key="Up" Command="{x:Static c:DateTimePicker.TickTimeComponentCommand}" CommandParameter="{u:Int 1}"/>
+                  <KeyBinding Key="Down" Command="{x:Static c:DateTimePicker.TickTimeComponentCommand}" CommandParameter="{u:Int -1}"/>
+                  <u:CustomInputBinding Gesture="{x:Static u:InputGestures.LeftTripleClick}" Command="{x:Static u:TextBoxBehavior.SelectAllCommand}"/>
+                </TextBox.InputBindings>
+              </TextBox>
             </c:TickUpDown>
             <c:TickUpDown x:Name="PART_month_tick" Grid.Column="2" Width="50">
               <TextBox x:Name="PART_month_text" Height="20" u:TextBoxBehavior.EnableArrowKeyTraverse="True" u:Behavior.DisablePaste="True"/>

src/client/spark/view/Controls/Time/DateTimePicker.xaml.cs

@@ -3,6 +3,7 @@ using mbts.ui.shell;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
@@ -14,7 +15,9 @@ namespace mbts.ui.controls {
    /// Interaction logic for DateTimePicker.xaml
    /// </summary>
    public class DateTimePicker : Control {
-      TimeTupleVM _vm;
+      public static readonly RoutedCommand TickTimeComponentCommand = new RoutedCommand();
+
+      DTPController _controller;
       bool _suspend_notify_vm;
 
       static DateTimePicker() =>
@@ -24,8 +27,8 @@ namespace mbts.ui.controls {
          new FrameworkPropertyMetadata(default(TimeTextTuple), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTimeTupleChanged));
       static void OnTimeTupleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
          var dtp = (DateTimePicker)d;
-         if (!dtp._suspend_notify_vm && dtp._vm != null)
-            dtp._vm.result = (TimeTextTuple)e.NewValue;
+         if (!dtp._suspend_notify_vm && dtp._controller != null)
+            dtp._controller.result = (TimeTextTuple)e.NewValue;
       }
       public TimeTextTuple TimeTuple { get => (TimeTextTuple)GetValue(TimeTupleProperty); set => SetValue(TimeTupleProperty, value); }
 
@@ -41,59 +44,74 @@ namespace mbts.ui.controls {
          var time = this.assert_template_child<TickUpDown>("PART_time_tick");
          var time_text = this.assert_template_child<TextBox>("PART_time_text");
 
-         if (_vm != null) _vm.PropertyChanged -= _vm_PropertyChanged;
-         _vm = new TimeTupleVM();
-         _vm.result = TimeTuple;
-         _vm.PropertyChanged += _vm_PropertyChanged;
+         if (_controller != null) _controller.PropertyChanged -= _vm_PropertyChanged;
+         _controller = new DTPController(time_text);
+         _controller.result = TimeTuple;
+         _controller.PropertyChanged += _vm_PropertyChanged;
+         time.CommandBindings.Add(new CommandBinding(TickTimeComponentCommand, (s, e) => {
+            _controller.tick_time_component((int)e.Parameter);
+         }));
+         time.CommandBindings.Add(new CommandBinding(TextBoxBehavior.SelectAllCommand, TextBoxBehavior.SelectAllCommandExecutedHandler));
 
          const int delay = 500;
-         time.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_time") { Source = _vm });
+         time.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_time") { Source = _controller });
          time.TickUpParameter = 1;
          time.TickDownParameter = -1;
          time.TickUpAltParameter = 60;
          time.TickDownAltParameter = -60;
-         time_text.SetBinding(TextBox.TextProperty, new Binding("time_text") { Source = _vm, Delay = delay, ValidatesOnExceptions = true });
-         _hooks.Add(time_text.SubscribePreviewTextInput((s, e) =>
-            e.Handled = !MatchAny(time_text.PeekText(e), RegexFilters.Time.StandardTime, RegexFilters.Time.MilitaryTime)
-         ));
+         time_text.SetBinding(TextBox.TextProperty, new Binding("time_text") { Source = _controller, Delay = delay, ValidatesOnExceptions = true });
+         _hooks.Add(time_text.SubscribePreviewTextInput((s, e) => {
+            string preview = time_text.PeekText(e);
+            if (RegexFilters.Time.StandardTimeOptionalSeconds.IsMatch(preview)) {
+               _controller.use_military_time = false;
+            } else if (RegexFilters.Time.MilitaryTimeOptionalSeconds.IsMatch(preview)) {
+               _controller.use_military_time = true;
+            } else {
+               e.Handled = true;
+            }
+         }));
 
-         month.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_month") { Source = _vm });
+         month.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_month") { Source = _controller });
          month.TickUpParameter = 1;
          month.TickDownParameter = -1;
-         month_text.SetBinding(TextBox.TextProperty, new Binding("month_text") { Source = _vm, Delay = delay });
+         month_text.SetBinding(TextBox.TextProperty, new Binding("month_text") { Source = _controller, Delay = delay });
          _hooks.Add(month_text.SubscribePreviewTextInput((s, e) =>
             e.Handled = !RegexFilters.Time.MonthAbbrev.IsMatch(month_text.PeekText(e))
          ));
 
-         day.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_day") { Source = _vm });
+         day.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_day") { Source = _controller });
          day.TickUpParameter = 1;
          day.TickDownParameter = -1;
-         day_text.SetBinding(TextBox.TextProperty, new Binding("day_text") { Source = _vm, Delay = delay });
+         day_text.SetBinding(TextBox.TextProperty, new Binding("day_text") { Source = _controller, Delay = delay });
          _hooks.Add(day_text.SubscribePreviewTextInput((s, e) =>
             e.Handled = !RegexFilters.Time.DaysInMonth.IsMatch(day_text.PeekText(e))
          ));
 
-         year.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_year") { Source = _vm });
+         year.SetBinding(TickUpDown.TickCommandProperty, new Binding("tick_year") { Source = _controller });
          year.TickUpParameter = 1;
          year.TickDownParameter = -1;
-         year_text.SetBinding(TextBox.TextProperty, new Binding("year_text") { Source = _vm, Delay = delay });
+         year_text.SetBinding(TextBox.TextProperty, new Binding("year_text") { Source = _controller, Delay = delay });
          _hooks.Add(year_text.SubscribePreviewTextInput((s, e) =>
             e.Handled = !RegexFilters.Time.Year.IsMatch(year_text.PeekText(e))
          ));
       }
 
       void _vm_PropertyChanged(object sender, PropertyChangedEventArgs e) {
-         if (e.PropertyName == nameof(TimeTupleVM.result)) {
+         if (e.PropertyName == nameof(DTPController.result)) {
             _suspend_notify_vm = true;
-            TimeTuple = _vm.result;
+            TimeTuple = _controller.result;
             _suspend_notify_vm = false;
          }
       }
 
-      private class TimeTupleVM : ViewModelBase {
+      // This is not exactly a view-model, bc it accesses the time TextBox directly so it can get/set the CaretIndex,
+      // which is used to determine which time-componenet - hh:mm:ss AM/PM - should be incremented/decremented via the up/down arrow-keys.
+      class DTPController : ViewModelBase {
+         readonly TextBox _time_text_box;
          TimeTextTuple _result;
 
-         public TimeTupleVM() {
+         public DTPController(TextBox time_text_box) {
+            _time_text_box = time_text_box;
             tick_time = new DelegateCommand<int>(_tick_time);
             tick_month = new DelegateCommand<int>(_tick_month);
             tick_day = new DelegateCommand<int>(_tick_day);
@@ -135,12 +153,52 @@ namespace mbts.ui.controls {
                RaisePropertyChanged(nameof(month_text), nameof(day_text), nameof(year_text), nameof(time_text));
             }
          }
+
+         public bool use_military_time { get; set; }
          public ICommand tick_time { get; }
          public ICommand tick_month { get; }
          public ICommand tick_day { get; }
          public ICommand tick_year { get; }
+         string _time_format => use_military_time ? StringFormats.Time.MilitaryWithSeconds : StringFormats.Time.StandardWithSeconds;
 
+         public void tick_time_component(int increment) {
+            _ensure_time_text_up_to_date();
+            var r = _result.result;
+            if (r.HasValue) {
+               int index = _time_text_box.CaretIndex;
+               using (detect_property_changes()) {
+                  DateTime dt;
+                  if (index <= 0) {
+                     dt = r.Value.AddHours(increment);
+                  } else {
+                     int segment = _time_text_box.Text.Take(index).Count(c => c == ':');
+                     switch (segment) {
+                        case 0: dt = r.Value.AddHours(increment); break;
+                        case 1: dt = r.Value.AddMinutes(increment); break;
+                        case 2:
+                           if (_time_text_box.Text.Take(index).Contains(' ')) {
+                              // toggle AM/PM
+                              dt = r.Value.AddHours(r.Value.Hour < 12 ? 12 : -12);
+                           } else {
+                              dt = r.Value.AddSeconds(increment);
+                           }
+                           break;
+                        default:
+                           dt = r.Value.AddSeconds(increment);
+                           break;
+                     }
+                  }
+                  _result = TimeTextTuple.FromDateTime(dt, _time_format);
+               }
+               _time_text_box.CaretIndex = index;
+            } else {
+               using (detect_property_changes())
+                  _force_valid_inputs();
+            }
+         }
+ 
          void _tick_time(int increment) {
+            _ensure_time_text_up_to_date();
             using (detect_property_changes()) {
                var r = _result.result;
                if (r.HasValue) {
@@ -187,6 +245,11 @@ namespace mbts.ui.controls {
                }
             }
          }
+ 
+         void _ensure_time_text_up_to_date() {
+            if (_time_text_box.IsKeyboardFocused)
+               _time_text_box.GetBindingExpression(TextBox.TextProperty)?.UpdateSource();
+         }
 
          void _force_valid_inputs() {
             var dt = DateTime.Today.Date;

src/client/spark/view/Converters/EnumCharacterCasingConverter.cs

@@ -8,6 +8,7 @@ namespace mbts.ui.converters
    internal class EnumCharacterCasingConverter : IValueConverter
    {
       public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) {
+         if (value is null) return string.Empty;
          string s = value is Enum ? EnumHelper.get_display_name((Enum)value) : value.ToString();
 
          CharacterCasing casing;

src/client/spark/view/Extensions/FrameworkElementLifeDependency.cs

@@ -70,7 +70,7 @@ namespace mbts.ui
 
       private void _subscribe() {
          Disposable.dispose(ref _sub);
-         _sub = _source.ObserveOnDispatcher().Subscribe(_on_data);
+         _sub = _source.OnDispatcher().Subscribe(_on_data);
       }
       private void _on_data(T data) { Target.SetValue(_target_property, _last_value = data); }
 

src/client/spark/view/Extensions/InputGestures.cs

@@ -0,0 +1,16 @@
+using System.Windows.Input;
+
+namespace mbts.ui {
+   class CustomInputBinding : InputBinding { }
+
+   static class InputGestures {
+      public static readonly InputGesture LeftTripleClick = new LeftTripleClickGesture();
+
+      class LeftTripleClickGesture : InputGesture {
+         public override bool Matches(object targetElement, InputEventArgs inputEventArgs) =>
+            inputEventArgs is MouseButtonEventArgs mouse_args &&
+            mouse_args.ChangedButton == MouseButton.Left &&
+            mouse_args.ClickCount == 3;
+      }
+   }
+}

src/client/spark/view/Extensions/TextElement/TextBoxBehavior.cs

@@ -7,7 +7,14 @@ using System.Windows.Input;
 
 namespace mbts.ui {
    static class TextBoxBehavior {
-      public static readonly RoutedCommand ReleaseCaptureCommand = new RoutedCommand();
+      #region RoutedCommands/Handlers
+      public static readonly RoutedCommand
+         ReleaseCaptureCommand = new RoutedCommand(),
+         SelectAllCommand = new RoutedCommand();
+
+      public static readonly ExecutedRoutedEventHandler SelectAllCommandExecutedHandler =
+         new ExecutedRoutedEventHandler((s, e) => (e.OriginalSource as TextBox ?? e.Source as TextBox ?? s as TextBox)?.SelectAll());
+      #endregion
 
       #region SelectAllOnFocus
 
@@ -168,7 +175,7 @@ namespace mbts.ui {
       public static void SetInputFilter(DependencyObject d, TextBoxInputFilter value) => d.SetValue(InputFilterProperty, value);
       #endregion
 
-      #region
+      #region IncrementDecrementOnMouseClick
       public static readonly DependencyProperty IncrementDecrementOnMouseClickProperty = DependencyProperty.RegisterAttached(
          "IncrementDecrementOnMouseClick", typeof(bool), typeof(TextBoxBehavior), new PropertyMetadata(false, IncrementDecrementOnMouseClickPropertyChanged)
          );

src/client/spark/view/Extensions/TextElement/TextElementHelper.cs

@@ -2,11 +2,28 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
+using System.Windows.Input;
+
+namespace mbts.ui {
+   static class TextElementHelper {
+      public static IDisposable SubscribeKeyboardFocus(this TextBox text_box, Action<bool> callback) {
+         text_box.GotKeyboardFocus += on_got_keyboard_focus;
+         text_box.LostKeyboardFocus += on_lost_keyboard_focus;
+         return Disposable.Create(() => {
+            text_box.GotKeyboardFocus -= on_got_keyboard_focus;
+            text_box.LostKeyboardFocus -= on_lost_keyboard_focus;
+         });
+         void on_got_keyboard_focus(object sender, KeyboardFocusChangedEventArgs e) {
+            if (e.NewFocus == text_box)
+               callback(true);
+
+         }
+         void on_lost_keyboard_focus(object sender, KeyboardFocusChangedEventArgs e) {
+            if (e.OldFocus == text_box)
+               callback(false);
+         }
+      }
 
-namespace mbts.ui
-{
-   public class TextElementHelper
-   {
       public static void GetTargetProperty(DependencyObject d, out FrameworkElement text_element, out DependencyProperty text_property) {
          text_element = (FrameworkElement)d;
          if (text_element is TextBox) text_property = TextBox.TextProperty;

src/client/spark/view/Resources/WindowStyle.xaml

@@ -22,7 +22,7 @@
     <Setter Property="Template">
       <Setter.Value>
         <ControlTemplate TargetType="{x:Type Window}">
-          <Border BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" Background="{TemplateBinding Background}" Loaded="style_loaded" x:Name="window_border" u:WindowStyle.IsNonClientArea="true">
+          <Border BorderThickness="{TemplateBinding BorderThickness}" Padding="{TemplateBinding Padding}" BorderBrush="{TemplateBinding BorderBrush}" Background="{TemplateBinding Background}" Loaded="style_loaded" x:Name="window_border" u:WindowStyle.IsNonClientArea="true">
             <Grid Margin="{TemplateBinding Margin}">
               <Grid.RowDefinitions>
                 <RowDefinition Height="20" />
@@ -134,8 +134,8 @@
           </Border>
           <ControlTemplate.Triggers>
             <DataTrigger Binding="{Binding Path=WindowState, RelativeSource={RelativeSource self}}" Value="Normal">
-              <Setter Property="Padding" Value="0,0,0,0" />
-              <Setter Property="BorderThickness" Value="7,1,2.66,2.66" TargetName="window_border" />
+              <Setter Property="Padding" Value="0,0,2,2" />
+              <Setter Property="BorderThickness" Value="7,1,1,1" TargetName="window_border" />
             </DataTrigger>
           </ControlTemplate.Triggers>
         </ControlTemplate>

src/client/spark/view/Shell/Login/PreloginWorkspaceEnumerator.cs

@@ -29,7 +29,7 @@ namespace mbts.ui.shell
 
       public async Task<IEnumerable<string>> get_workspaces(User user) {
          if (!_cache.TryGetValue(user.id, out List<string> result)) {
-            using (var svc = new UserUISettings(user.id, _persist)) {
+            using (var svc = new UserUISettings(user.id, _persist, null)) {
                var workspaces = await svc.query<WorkspaceDefinition>(WorkspacesModel.WORKSPACE_NAMESPACE, ".*");
                result = workspaces.Select(w => w.key).ToList();
                _cache[user.id] = result;

src/client/spark/view/Shell/WindowManager.cs

@@ -38,7 +38,7 @@ namespace mbts.ui.shell {
          _window_settings = settings;
          _window_factory = factory;
          _undo = undo;
-         _dispose = bus.subscribe(SparkTags.ShowWindow).ObserveOnDispatcher().Subscribe(w => add(w).ignore());
+         _dispose = bus.subscribe(SparkTags.ShowWindow).OnDispatcher().Subscribe(w => add(w).ignore());
       }
 
       #region Window creation

src/client/spark/view/Spark/ContractPicker/ContractPickerModel.cs

@@ -27,7 +27,7 @@ namespace mbts.spark
 {
    internal class ContractPickerModel : ViewModelBase {
 
-      private const string dot = "•";
+      private const string dot = "•";
 
       public ContractPickerModel(IBus bus, bool edit_mode, SecurityCriteria existing_criteria, SecurityCriteria world_view_filter = null) {
          _bus = bus;
@@ -38,7 +38,7 @@ namespace mbts.spark
          _world_view_filter = world_view_filter;
          securities_view = CollectionViewSource.GetDefaultView(securities);
          (securities_view as ListCollectionView).CustomSort = new SecuritySorter();
-         _subs.Add(_bus.subscribe(SecuritiesTag).ObserveOnDispatcher().Subscribe(on_securities_changed));
+         _subs.Add(_bus.subscribe(SecuritiesTag).OnDispatcher().Subscribe(on_securities_changed));
 
          add_criteria_command = new DelegateCommand(
             execute: _ => {
@@ -197,10 +197,6 @@ namespace mbts.spark
          selected_securities = secs.Select(s => s.Id).ToList();
          ok_button_command.TryRaiseCanExecuteChanged();
          _compose_criteria_clause_name();
-
-         // _security_in_criteria is our fun to be returned to our callers
-         // test on click -- verify our func works
-         //var results = all_securities.Select(all => all.Value.security).Where(x => _security_in_criteria(x)).ToList();
       }
 
       private void on_securities_changed(IReadOnlyDictionary<uint, SecurityMD> changed_securities) {
@@ -212,10 +208,6 @@ namespace mbts.spark
             all_securities = changed_securities;
          }
 
-         securities.sync_with(all_securities
-            .Select(entry => entry.Value.security)
-         );
-
          _update_exchanges();
          _update_security_types();
          _update_symbols();
@@ -327,7 +319,6 @@ namespace mbts.spark
             .Select(s => s.Value.security.Symbol)
             .Distinct()
          );
-            
       }
 
       private void _update_securities() {

src/client/spark/view/Spark/Core/OrderUtils.cs

@@ -149,6 +149,15 @@ namespace mbts.spark {
          }
       }
 
+      public static string abbreviate(this Side side) {
+         switch (side) {
+            case Side.Buy: return "B";
+            case Side.Sell: return "S";
+            case Side.Undefined:
+            default: return "E";
+         }
+      }
+
       public static string order_sub_type_display_name(OrderSubType sub_type, bool use_long_name) {
          switch(sub_type) {
             case OrderSubType.HedgingLeg:

src/client/spark/view/Spark/Core/TickUtils.cs

@@ -170,6 +170,13 @@ namespace mbts.spark {
       public static bool tick_equals(this ContractSpecificationImmutable contract, double x, double y) =>
          MathUtils.RoundFractionalUnits(x, contract.LowTick) == MathUtils.RoundFractionalUnits(y, contract.LowTick);
 
+      public static IEqualityComparer<double> tick_equality_comparer(this ContractSpecificationImmutable contract)
+      {
+         var eq = EqualityComparer.Create((double a, double b) => TickUtils.tick_equals(contract, a, b), 
+                                           x => MathUtils.RoundFractionalUnits(x, contract.LowTick));
+         return eq;
+      }
+
       public static double round_to_tick(this ContractSpecificationImmutable spec, double value) {
          double intpart = (long)value;
          double floatpart = value % 1;

src/client/spark/view/Spark/Ladder/LadderGridHost.cs

@@ -204,12 +204,12 @@ namespace mbts.spark {
       protected override async void OnMouseDown(MouseButtonEventArgs e) {
          Keyboard.ClearFocus();
          Focus();
-         if (e.ChangedButton == MouseButton.Middle)
+         var point = e.GetPosition(this);
+         var column = _column_for_point(point);
+         if (column.column_type == ColumnType.Price && e.ChangedButton == MouseButton.Middle)
             _scroll_to_center();
          else if (_settings != null) {
-            var point = e.GetPosition(this);
             var price = price_for_point(point);
-            var column = _column_for_point(point);
             Side? bs = null;
             if (column.column_type == ColumnType.Bid) bs = Side.Buy;
             if (column.column_type == ColumnType.Ask) bs = Side.Sell;
@@ -340,7 +340,7 @@ namespace mbts.spark {
             _price_comparer = Comparer<double>.Create((x, y) => security.ContractSpec.tick_equals(x, y) ? 0 : y.CompareTo(x));
             _price_dirty = true;
             _vm.on_tick += _tick;
-            _settings_sub = _vm.settings.ObserveOnDispatcher().Subscribe(_settings_updated);
+            _settings_sub = _vm.settings.OnDispatcher().Subscribe(_settings_updated);
             _tick_sub = Disposable.Create(() => _vm.on_tick -= _tick);
          }
       }
@@ -533,6 +533,7 @@ namespace mbts.spark {
          _visualHost.AddVisualChild(_mid_mkt_break_vis);
          _visualHost.AddVisualChild(_ask_mkt_break_vis);
          _visualHost.AddVisualChild(_bid_mkt_break_vis);
+         _render_grid_background();
          _init_tactile_adorner();
          // this effectively sets the background of the "Last" column
          if (_scrollViewer != null) {

src/client/spark/view/Spark/Ladder/LadderOrderVM.cs

@@ -13,9 +13,10 @@ using System.Windows.Input;
 using System.Windows.Media;
 
 namespace mbts.spark {
-   class LadderOrderVM : DisposableViewModelBase, IEquatable<LadderOrderVM> {
+   class LadderOrderVM : DisposableViewModelBase {
       #region Colors
       static readonly Color _colorbg = Colors.White, _darkbg = Color.FromRgb(0xbf, 0xbf, 0xbf);
+      static readonly Brush _color_bg_brush = _colorbg.rgb_color().rgb_brush();
       static Brush mkbrush(Color color, Color endcolor, double pct_complete) {
          GradientStopCollection stops = new GradientStopCollection();
          stops.Add(new GradientStop(color, 0.0));
@@ -34,7 +35,8 @@ namespace mbts.spark {
       readonly Property<FontFamily> _font_family;
       readonly Property<FontWeight> _font_weight;
       readonly Property<double> _font_size;
-      readonly Property<Brush> _foreground;
+      readonly Property<Brush> _foreground, _background, _hoverbackground, _border;
+      readonly Property<string> _summary, _description;
       IObservable<LadderSettings.BadgeStyle> _bs;
       LadderSettings.BadgeStyle _current_badge_style;
       int _n_active_price_change_ops = 0;
@@ -56,25 +58,26 @@ namespace mbts.spark {
          _font_weight = backing(nameof(font_weight), parent.settings, get_font_weight, get_font_weight(fs));
          _font_size = backing(nameof(font_size), parent.settings, get_font_size, get_font_size(fs));
          _foreground = backing(nameof(foreground), parent.settings, get_foreground, get_foreground(fs));
+         _background = backing(nameof(background), _color_bg_brush);
+         _hoverbackground = backing(nameof(hoverbackground), _color_bg_brush);
+         _border = backing(nameof(border), _color_bg_brush);
+         _summary = backing(nameof(summary), string.Empty);
+         _description = backing(nameof(description), string.Empty);
          FontFamily get_font_family(LadderSettings s) => new FontFamily(s.orders_column.font_family);
          FontWeight get_font_weight(LadderSettings s) => ui.utility.text.TextUtils.from_open_type_weight_safe(s.orders_column.font_weight);
          double get_font_size(LadderSettings s) => s.orders_column.font_size;
          Brush get_foreground(LadderSettings s) => s.orders_column.foreground.rgb_brush();
-         _text = _bottom_line = _top_line = string.Empty;
+         //
+         add_order(o);
          _dispose = Disposable.Create(
-            _bs.Subscribe( badge => {
+            _bs.Subscribe(badge => {
                _current_badge_style = badge;
                _set_badge_text();
             })
          );
-
-         //
-         add_order(o);
       }
 
-
-
-      void _init() {
+      public void update() {
          // update brushes
          Color color;
          switch (side) {
@@ -86,35 +89,33 @@ namespace mbts.spark {
          }
          var darker = BTSColor.darken2(color.R, color.G, color.B, 0.75);
          Color dark = new Color() { A = 255, R = darker.r, G = darker.g, B = darker.b };
-         var completion = _parent_and_child_not_sharing_slot().Sum(order => OrderUtils.filled(order)) / _parent_and_child_not_sharing_slot().Sum(order => OrderUtils.quantity(order));
-         background = mkbrush(color, _colorbg, completion);
-         hoverbackground = mkbrush(dark, _darkbg, completion);
+         //var completion = _parent_and_child_not_sharing_slot().Sum(order => OrderUtils.filled(order)) / _parent_and_child_not_sharing_slot().Sum(order => OrderUtils.quantity(order));
+         background = _color_bg_brush; //mkbrush(color, _colorbg, 0);
+         hoverbackground = mkbrush(dark, _darkbg, 0);
          border = new SolidColorBrush(color);
          filled = _parent_and_child_not_sharing_slot().Select(order => OrderUtils.filled(order)).Sum();
          working_quantity = _parent_and_child_not_sharing_slot().Select(order => order.working_quantity()).Sum();
          quantity = _parent_and_child_not_sharing_slot().Select(order => order.State.Quantity).Sum();
 
+         if (_orders.Count > 0)
+         {
+            summary = _orders.Values.Select(order => order.short_description(_parent.security.ContractSpec)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}");
+            description = _orders.Values.Select(order => order.full_description(_parent.security)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}");
+         }
          _set_badge_text();
       }
 
       private void _set_badge_text() {
-         if (_orders.Count > 0) {
-            switch (_current_badge_style) {
-               case LadderSettings.BadgeStyle.Alternate:
-                  //text = $"{_buy_sell_indicator}:{filled} 
-                  top_line = $"{_buy_sell_indicator}:{filled}";
-                  bottom_line = $"W:{ working_quantity}";
-                  break;
-               case LadderSettings.BadgeStyle.Normal:
-               default:
-                  text = $"{filled}/{quantity}"; break;
-            }
-         }
+         text_lines = BadgeRender.format(side, quantity, filled, _current_badge_style);
+         RaisePropertyChanged(nameof(text_lines));
       }
 
       public void add_order(OrderRecordImmutable new_order) {
          _orders[new_order.Key] = new_order;
-         _init();
+      }
+
+      public void remove_order(uint order_key) {
+         _orders.Remove(order_key);
       }
 
       //public void update(OrderRecordImmutable neworder) {
@@ -133,61 +134,13 @@ namespace mbts.spark {
             if (distinct_sides.Count() > 1) {
                return Side.Undefined;
             }
-            return distinct_sides.First();
+            return distinct_sides.FirstOrDefault();
          }
       }
 
-      string _buy_sell_indicator {
-         get {
-            switch (side) {
-               case Side.Buy: return "B";
-               case Side.Sell: return "S";
-               case Side.Undefined:
-               default:
-                  return "E";
-            }
-         }
-      }
-      
       IEnumerable<OrderRecordImmutable> _parent_and_child_not_sharing_slot() => _orders.Values.Where(o => !_orders.ContainsKey(o.ParentKey));
 
-      private string _text;
-      public string text {
-         get { return _text; }
-         private set {
-            _text = value;
-            if (value != string.Empty) {
-               top_line = string.Empty;
-               bottom_line = string.Empty;
-            }
-            RaisePropertyChanged(); }
-      }
-
-      private string _top_line;
-      public string top_line {
-         get { return _top_line; }
-         private set {
-            _top_line = value;
-            if (value != string.Empty) {
-               text = string.Empty;
-            } 
-            RaisePropertyChanged();
-         }
-      }
-      private string _bottom_line;
-      public string bottom_line {
-         get { return _bottom_line; }
-         private set {
-            _bottom_line = value;
-            if (value != string.Empty) {
-               text = string.Empty;
-            }
-            RaisePropertyChanged();
-         }
-      }
-
-      public string summary => _orders.Values.Select(order => order.short_description(_parent.security.ContractSpec)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}");
-      public string description => _orders.Values.Select(order => order.full_description(_parent.security)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}");
+      public IReadOnlyList<string> text_lines { get; private set; }
       public bool has_parent => _orders.Values.Any( order => order.has_parent());
       public bool has_phantom_price => !double.IsNaN(_phantom_price);
 
@@ -204,10 +157,11 @@ namespace mbts.spark {
       public FontWeight font_weight => _font_weight.Value;
       public double font_size => _font_size.Value;
       public Brush foreground => _foreground.Value;
-      public Brush background { get; private set; }
-      public Brush hoverbackground { get; private set; }
-      public Brush header_brush => _orders.Values.FirstOrDefault().Def.Side == Side.Buy ? BTSColors.MarketData.bid : BTSColors.MarketData.ask;
-      public Brush border { get; private set; }
+      public Brush background { get => _background.Value; private set => _background.Value = value; }
+      public Brush hoverbackground { get => _hoverbackground.Value; private set => _hoverbackground.Value = value; }
+      public Brush border { get => _border.Value; private set => _border.Value = value; }
+      public string summary { get => _summary.Value; private set => _summary.Value = value; }
+      public string description { get => _description.Value; private set => _description.Value = value; }
       public IEnumerable<OrderRecordImmutable> orders => _orders.Values;
 
       void _cancel_order() {
@@ -239,40 +193,8 @@ namespace mbts.spark {
          }
       }
 
-
-      public override bool Equals(object obj) => this.safe_equals(obj as LadderOrderVM, _non_null_equals);
-      public override int GetHashCode() {
-         // can't use aggregate_hash since OrderRecordImmutable is not a reference type
-         unchecked {
-            int hash = 19;
-            foreach (var o in _orders.Values) {
-               hash = hash * 31 + o.GetHashCode();
-            }
-            return hash;
-         }
-      }
-      public bool Equals(LadderOrderVM other) => this.safe_equals(other, _non_null_equals);
-      static bool _non_null_equals(LadderOrderVM x, LadderOrderVM y) {
-         // null checks already taken care of safe_equals
-         // same object ?
-         if (object.ReferenceEquals(x,y)) return true; 
-         
-         // if the Dicts have different count, we have different objects
-         if (x._orders.Count != y._orders.Count) return false;
-
-         // are the keys the same ?
-         foreach(uint kx in x._orders.Keys) {
-            if (!y._orders.ContainsKey(kx))
-               return false;
-         }
-
-         // I don't think we have to look at the Dictionary values
-         // since the keys originate from the OrderRecordImmutable.key
-         //foreach (uint kx in x._orders.Keys) {
-         //   if (!x._orders[kx].Equals(y._orders[kx)
-         //         return false;
-         //}
-         return true;
+      public override string ToString() {
+         return $"Price: {this.price} Order Count: {this.orders.Count()}";
       }
    }
-}
+}

src/client/spark/view/Spark/Ladder/LadderOrdersHost.cs

@@ -143,8 +143,9 @@ namespace mbts.spark {
             return price_cell.panel;
          else if (_price_list != null && !double.IsNaN(_row_height)) {
             var panel = new StackPanel() {               
+               Margin = Badge.DefaultMargin,
                Orientation = Orientation.Horizontal,
-               MaxWidth = _col_width,
+               MaxWidth = _col_width
                //MaxHeight = _row_height,
                //ClipToBounds = true
             };

src/client/spark/view/Spark/Ladder/LadderSettings.cs

@@ -1,5 +1,6 @@
 using bts.api.orderman;
 using mbts.ui;
+using mbts.utils;
 using ProtoBuf;
 using System;
 using System.Linq;
@@ -124,8 +125,6 @@ namespace mbts.spark {
                last_column = last_column,
                calculator_buttons = new[] { 1, 5, 10, 25, 50, 100 },
                scroll_bar_visible = false,
-               ticks_to_recenter = 10,
-               seconds_to_recenter = 300,
                default_order_type = CustomOrderDefinition.CustomOneofCase.Limit,
                default_time_in_force = TimeInForce.Day,
                animate_recenter = true,
@@ -163,10 +162,8 @@ namespace mbts.spark {
       public int[] calculator_buttons { get; set; }
       [ProtoMember(10)]
       public bool scroll_bar_visible { get; set; }
-      [ProtoMember(11)]
-      public int ticks_to_recenter { get; set; }
-      [ProtoMember(12)]
-      public int seconds_to_recenter { get; set; }
+      // USED [ProtoMember(11)]
+      // USED [ProtoMember(12)]
       [ProtoMember(13)]
       public CustomOrderDefinition.CustomOneofCase default_order_type { get; set; }
       [ProtoMember(14)]
@@ -197,11 +194,8 @@ namespace mbts.spark {
          other.price_column.safe_equals(price_column) &&
          other.calculator_buttons.safe_equals(calculator_buttons, (a, b) => a.SequenceEqual(b)) &&
          other.scroll_bar_visible == scroll_bar_visible &&
-         other.ticks_to_recenter == ticks_to_recenter &&
-         other.seconds_to_recenter == seconds_to_recenter &&
          other.default_order_type == default_order_type &&
          other.default_time_in_force == default_time_in_force &&
-         other.seconds_to_recenter == seconds_to_recenter &&
          other.size == size &&
          other.animate_recenter == animate_recenter &&
          other.badge_style == badge_style &&
@@ -213,26 +207,24 @@ namespace mbts.spark {
       public override bool Equals(object obj) => Equals(obj as LadderSettings);
 
       public override int GetHashCode() =>
-         row_height.GetHashCode() +
-         grid_line_color.GetHashCode() +
-         orders_column.GetHashCode() +
-         bid_column.GetHashCode() +
-         ask_column.GetHashCode() +
-         price_column.GetHashCode() +
-         last_column.GetHashCode() +
-         calculator_buttons.GetHashCode() +
-         scroll_bar_visible.GetHashCode() +
-         ticks_to_recenter.GetHashCode() +
-         seconds_to_recenter.GetHashCode() +
-         default_order_type.GetHashCode() +
-         default_time_in_force.GetHashCode() +
-         seconds_to_recenter.GetHashCode() +
-         size.GetHashCode() +
-         animate_recenter.GetHashCode() +
-         badge_style.GetHashCode() +
-         bid_break_line.GetHashCode() +
-         ask_break_line.GetHashCode() +
-         mid_break_line.GetHashCode() +
-         alternate_order_size.GetHashCode();
+         EqualityComparer.aggregate_hash(
+            row_height.GetHashCode(),
+            grid_line_color.GetHashCode(),
+            orders_column.GetHashCode(),
+            bid_column.GetHashCode(),
+            ask_column.GetHashCode(),
+            price_column.GetHashCode(),
+            last_column.GetHashCode(),
+            calculator_buttons.GetHashCode(),
+            scroll_bar_visible.GetHashCode(),
+            default_order_type.GetHashCode(),
+            default_time_in_force.GetHashCode(),
+            size.GetHashCode(),
+            animate_recenter.GetHashCode(),
+            badge_style.GetHashCode(),
+            bid_break_line.GetHashCode(),
+            ask_break_line.GetHashCode(),
+            mid_break_line.GetHashCode(),
+            alternate_order_size.GetHashCode());
    }
 }

src/client/spark/view/Spark/Ladder/LadderSettingsVM.cs

@@ -1,8 +1,8 @@
-using bts.spark;
-using mbts.spark.utilities;
+using bts.api;
 using mbts.ui;
 using mbts.ui.controls.color_picker;
 using mbts.ui.shell;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
@@ -14,6 +14,7 @@ namespace mbts.spark {
    class LadderSettingsVM : ViewModelBase, IWindowSettingsVM<LadderSettings> {
       readonly Property<LadderSettings.BadgeStyle> _badge_style;
       readonly Property<uint> _alternate_order_size;
+      readonly DelegateProperty<double> _row_height;
       LadderSettings _current;
       LadderColumnSettingsVM
          _orders = new OrdersColumnSettingsVM(),
@@ -30,6 +31,13 @@ namespace mbts.spark {
          _badge_style = backing<LadderSettings.BadgeStyle>(nameof(badge_style));
          _badge_style.Changed += _badge_style_Changed;
          _alternate_order_size = backing<uint>(nameof(alternate_order_size));
+         _row_height = backing(nameof(row_height), () => LadderRender.measure_row_height(get_result()));
+         _orders.font_size_changed += on_font_size_changed;
+         _bid.font_size_changed += on_font_size_changed;
+         _price.font_size_changed += on_font_size_changed;
+         _ask.font_size_changed += on_font_size_changed;
+         _last.font_size_changed += on_font_size_changed;
+         void on_font_size_changed(double oldval, double newval) => _row_height.refresh();
       }
 
       private void _badge_style_Changed(LadderSettings.BadgeStyle oldval, LadderSettings.BadgeStyle newval) {
@@ -38,6 +46,7 @@ namespace mbts.spark {
          } else if (newval == LadderSettings.BadgeStyle.Normal && _orders.font_size == 7) {
             _orders.font_size = 10;
          }
+         _row_height.refresh();
       }
 
       public LadderSettings.BadgeStyle badge_style {
@@ -50,6 +59,8 @@ namespace mbts.spark {
          set => _alternate_order_size.Value = value;
       }
 
+      public double row_height => _row_height.Value;
+
       public IEnumerable<LadderColumnSettingsVM> column_items {
          get {
             yield return _orders;
@@ -89,7 +100,6 @@ namespace mbts.spark {
       }
 
       public LadderSettings get_result() {
-         const double row_padding = 12;
          var clone = SparkUtils.clone_proto(_current);
          clone.badge_style = badge_style;
          clone.alternate_order_size = alternate_order_size;
@@ -101,13 +111,7 @@ namespace mbts.spark {
          clone.bid_break_line = _bid_mkt_line.get_settings();
          clone.ask_break_line = _ask_mkt_line.get_settings();
          clone.mid_break_line = _mid_mkt_line.get_settings();
-         clone.row_height = new[] {
-            clone.orders_column,
-            clone.bid_column,
-            clone.price_column,
-            clone.ask_column,
-            clone.last_column
-         }.Max(cs => cs.font_size) + row_padding;
+         clone.row_height = LadderRender.measure_row_height(clone);
          return clone;
       }
  
@@ -131,6 +135,7 @@ namespace mbts.spark {
             _background = backing(nameof(background), Colors.White);
             _font_display_name = backing(nameof(font_display_name),
                () => TextUtils.display_name(font_family, font_weight, font_size), nameof(font_family), nameof(font_weight), nameof(font_size));
+            _font_size.Changed += (oldval, newval) => font_size_changed?.Invoke(oldval, newval);
          }
 
          public string name { get; }
@@ -145,6 +150,7 @@ namespace mbts.spark {
          public Color background { get => _background.Value; set => _background.Value = value; }
          public ObservableCollection<ColorPaletteVM> foreground_palettes { get; }
          public ObservableCollection<ColorPaletteVM> background_palettes { get; }
+         public event Action<double, double> font_size_changed;
 
          public virtual string sample_text => "999-56789.01234";
 
@@ -178,7 +184,9 @@ namespace mbts.spark {
       public class OrdersColumnSettingsVM : LadderColumnSettingsVM, ITemplateSelectorKey {
          public OrdersColumnSettingsVM() : base("Orders") { }
 
-         public override string sample_text => "12/50";
+         public uint sample_quantity { get; } = 50;
+         public uint sample_filled { get; } = 12;
+         public Side sample_side { get; } = Side.Buy;
          public Brush badge_border { get; } = new SolidColorBrush(BTSColors.MarketData.ask);
          public Brush badge_background { get; } = Brushes.White;
 
@@ -213,4 +221,4 @@ namespace mbts.spark {
             };
       }
    }
-}
+} 

src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml

@@ -11,6 +11,7 @@
   TextElement.FontSize="{x:Static u:FontSizes.Small}"
 >
   <UserControl.Resources>
+    <c:BadgeTextLinesConverter x:Key="BadgeTextLinesConverter"/>
     <u:KeyedTemplateSelector x:Key="ColumnSampleTemplateSelector">
       <u:KeyedTemplateSelector.Default>
         <DataTemplate>
@@ -28,18 +29,23 @@
       <u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsView.OrdersColumnSampleTemplateKey}">
         <DataTemplate>
           <c:Badge
-            Width="50"
-            Height="20"
             Background="{Binding badge_background}"
             BorderBrush="{Binding badge_border}"
-            BorderThickness="3"
             FontFamily="{Binding font_family}"
             FontSize="{Binding font_size}"
             FontWeight="{Binding font_weight}"
             Foreground="{Binding foreground, Converter={StaticResource ColorToBrushConverter}}"
-            Text="{Binding sample_text}"
-            VerticalAlignment="Center"
-          />
+            Width="{x:Static c:Badge.DefaultWidth}"
+          >
+            <c:Badge.TextLines>
+              <MultiBinding Converter="{StaticResource BadgeTextLinesConverter}">
+                <Binding Path="sample_side"/>
+                <Binding Path="sample_quantity"/>
+                <Binding Path="sample_filled"/>
+                <Binding Path="DataContext.badge_style" RelativeSource="{RelativeSource AncestorType=usp:LadderSettingsView}"/>
+              </MultiBinding>
+            </c:Badge.TextLines>
+          </c:Badge>
         </DataTemplate>
       </u:TemplateSelectorKeyValue>
     </u:KeyedTemplateSelector>
@@ -82,7 +88,7 @@
         <ItemsControl Grid.Row="1" ItemsSource="{Binding column_items}" Margin="8,0">
           <ItemsControl.ItemTemplate>
             <DataTemplate>
-              <Grid Height="27">
+              <Grid Height="{Binding DataContext.row_height, Mode=OneWay, RelativeSource={RelativeSource AncestorType=usp:LadderSettingsView}}">
                 <Grid.ColumnDefinitions>
                   <ColumnDefinition Width="Auto" SharedSizeGroup="c0"/>
                   <ColumnDefinition SharedSizeGroup="c1"/>
@@ -124,7 +130,7 @@
                   <c:FontPicker SelectedFontSize="{Binding font_size}" Typeface="{Binding typeface}"/>
                 </c:PopupControl>
                 <Border Grid.Column="4" Background="{Binding background, Converter={StaticResource ColorToBrushConverter}}" BorderBrush="Black" BorderThickness="2,0,0,0" Padding="4,0">
-                  <ContentControl Content="{Binding}" ContentTemplateSelector="{StaticResource ColumnSampleTemplateSelector}"/>
+                  <ContentControl Content="{Binding}" ContentTemplateSelector="{StaticResource ColumnSampleTemplateSelector}" VerticalContentAlignment="Center"/>
                 </Border>
                 <Rectangle Grid.Column="1" Grid.ColumnSpan="5" Fill="DimGray" Height="1" HorizontalAlignment="Stretch" VerticalAlignment="Bottom"/>
               </Grid>

src/client/spark/view/Spark/Ladder/LadderVM.cs

@@ -1,5 +1,6 @@
 using bts.api;
 using bts.api.orderman;
+using bts.shell;
 using bts.spark;
 using mbts.co2;
 using mbts.persist;
@@ -22,14 +23,18 @@ namespace mbts.spark {
       readonly LadderModel _model;
       readonly Property<double> _high, _low, _change, _open, _settlement;
       readonly Property<ulong> _volume;
-      readonly Property<bool> _revert;
+      readonly Property<bool> _auto_clear;
       readonly Property<Brush> _bid_background, _bid_foreground, _ask_background, _ask_foreground;
       IWindowSettingsManager<LadderSettings> _settings_manager;
       ulong _misc_time = 0;
+      IEqualityComparer<double> _equality;
+      Dictionary<double, LadderOrderVM> _slot_price_vs_orders;
 
       public LadderVM(IBus bus, LadderModel model, IWindowSettingsManager<LadderSettings> settings_manager) {
          _bus = bus;
          _model = model;
+         _equality = TickUtils.tick_equality_comparer(_model.security.ContractSpec);
+         _slot_price_vs_orders = new Dictionary<double, LadderOrderVM>(_equality);
          _settings_manager = settings_manager;
          _high = backing(nameof(high), double.NaN);
          _low = backing(nameof(low), double.NaN);
@@ -37,7 +42,7 @@ namespace mbts.spark {
          _open = backing(nameof(open), double.NaN);
          _settlement = backing(nameof(settlement), double.NaN);
          _volume = backing(nameof(volume), 0ul);
-         _revert = backing(nameof(revert), false);
+         _auto_clear = backing(nameof(auto_clear), false);
          _status = backing(nameof(status_message), "");
          _status_brush = backing(nameof(status_background), (Brush)BTSColors.UI.spark_menu_background);
          // brush props
@@ -46,7 +51,7 @@ namespace mbts.spark {
          _ask_background = brush_prop(nameof(ask_background), s => s.ask_column.background.rgb_brush());
          _ask_foreground = brush_prop(nameof(ask_foreground), s => s.ask_column.foreground.rgb_brush());
          Property<Brush> brush_prop(string name, Func<LadderSettings, Brush> get_brush) =>
-            backing(name, settings_manager.subscribe_current().ObserveOnDispatcher(), get_brush);
+            backing(name, settings_manager.subscribe_current().OnDispatcher(), get_brush);
          //
          send_order_command = new DelegateCommand<(double price, Side? side, bool size_from_alternate)>(send_order);
          cancel_command = new AsyncCommand<LadderModel.CancelType>(_model.cancel_orders, true);
@@ -62,46 +67,77 @@ namespace mbts.spark {
             return dialog;
          }, -500, -500);
 
-         var under_orders = new ObservableCollection<OrderRecordImmutable>();
          orders = new ObservableCollection<LadderOrderVM>();
-            //new ObservableAutoWrapper<LadderOrderVM, OrderRecordImmutable>(under_orders, rec => new LadderOrderVM(rec, this, _bus, _settings_manager.subscribe_current().Select(s => s.badge_style)));
 
          _dispose = Disposable.Create(
             settings_command,
             order_properties_vm = new OrderPropertiesEditorVM(model.order_gateway, Observable.Return(security), _settings_manager.subscribe_current().Select(s => new InlineOrderProperties(model.order_gateway, s))),
             size_calculator = new CalculatorLogic(0, _settings_manager.subscribe_current().Select(s => s.calculator_buttons)),
-            bus.subscribe(SparkTags.LogActivity).ObserveOnDispatcher().Subscribe(status_update),
-            // 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
-            model.order_gateway.working_orders.ObserveOnDispatcher().Subscribe(working => {
-               under_orders.sync_with(working.Values.Where(o => o.Def.SecurityKey == security.Id && o.is_non_terminal()));
+            bus.subscribe(SparkTags.LogActivity).OnDispatcher().Subscribe(status_update),
+            model.order_gateway.working_orders.OnDispatcher().Subscribe(working => {
                // Here we manage N orders to 1 price slot in the ladder
-               // there is likely a smarter way to do this than creating this anew each time
-               // need to do something about stop and stop limits in here
-               var slot_price_vs_orders = new Dictionary<double, LadderOrderVM>();
-               foreach(var uo in under_orders) {
-                  var slot_price_target = uo.price();
-                  var order_type = uo.order_type();
-                  var filled = uo.filled();
+
+               Dictionary<double, HashSet<uint>> orders_used_in_this_update = new Dictionary<double, HashSet<uint>>(_equality);
+               var ladders_orders = working.Values.Where(o => o.Def.SecurityKey == security.Id);
+               foreach (var wo in ladders_orders) {
+                  var slot_price_target = wo.price();
+                  var order_type = wo.order_type();
+                  var filled = wo.filled();
                   if (order_type == CustomOrderDefinition.CustomOneofCase.Stop) {
                      // if the stop order has been submitted but hasn't been triggered
                      // we draw the badge at the stop/trigger price, else the price price
-                     if (filled == 0) { slot_price_target = uo.stop_price(); }
+                     if (filled == 0) { slot_price_target = wo.stop_price(); }
                   } else if (order_type == CustomOrderDefinition.CustomOneofCase.StopLimit) {
                      // consistent behavior as Stop order above.
-                     if (filled == 0) { slot_price_target = uo.stop_limit_price(); }
+                     if (filled == 0) { slot_price_target = wo.stop_limit_price(); }
                   }
 
-                  slot_price_vs_orders.TryGetValue(slot_price_target, out LadderOrderVM slot_vm);
-                  if (slot_vm != null) {
-                     slot_vm.add_order(uo);
+                  if (_slot_price_vs_orders.TryGetValue(slot_price_target, out LadderOrderVM slot_vm)) {
+                     slot_vm.add_order(wo);
                   } else {
-                     slot_vm = new LadderOrderVM(uo, slot_price_target, this, _bus, _settings_manager.subscribe_current().Select(s => s.badge_style));
+                     slot_vm = new LadderOrderVM(wo, slot_price_target, this, _bus, _settings_manager.subscribe_current().Select(s => s.badge_style));
+                     _slot_price_vs_orders[slot_price_target] = slot_vm;
                   }
-                  slot_price_vs_orders[slot_price_target] = slot_vm;
+
+                  // keep track of slot prices vs orders; we use this below to remove orders from the LadderOrderVMs
+                  // that are not found in this callback run
+                  if (!orders_used_in_this_update.TryGetValue(slot_price_target, out HashSet<uint> orders_at_level)) {
+                     orders_at_level = new HashSet<uint>();
+                  }
+                  orders_at_level.Add(wo.Key);
+                  orders_used_in_this_update[slot_price_target] = orders_at_level;
+
                }
-               orders.sync_with(slot_price_vs_orders.Values);
-               orders_cache = working;
+
+               // remove any orders from the lovm that aren't in here
+               foreach(var kvp in orders_used_in_this_update) {
+                  var slot_vm = _slot_price_vs_orders[kvp.Key];
+                  foreach(var existing_order_key in slot_vm.orders.Select(o => o.Key).ToList()) {
+                     if (!kvp.Value.Contains(existing_order_key)) {
+                        slot_vm.remove_order(existing_order_key);
+                     }
+                  }
+               }
+
+
+               // update dirty brushes and text
+               foreach (var lovm in _slot_price_vs_orders.Values) {
+                  lovm.update();
+               }
+
+               // complete removal of slots that were not updated
+               // orders_used_in_this_update.Keys are the price levels in the update
+               foreach (var slot_price in _slot_price_vs_orders.Keys.ToList()) {
+                  if (!orders_used_in_this_update.Keys.Contains(slot_price)) {
+                     _slot_price_vs_orders.TryGetValue(slot_price, out LadderOrderVM removal_candidate);
+                     if (removal_candidate != null) {
+                        removal_candidate.Dispose();
+                     }
+                     _slot_price_vs_orders.Remove(slot_price);
+                  }
+               }
+
+               orders.sync_with(_slot_price_vs_orders.Values);
             }),
             WorkLoop.Start($"Ladder '{security}'", _tick)
          );
@@ -120,7 +156,7 @@ namespace mbts.spark {
       public ICommand status_click_command => SparkCommands.ShowActivityLog.ICommand(_bus);
 
       public async void status_update(Activity a) {
-         if (a.security == _model.security) {
+         if (a.security == _model.security && a.category != ActivityLogCategory.modify) {
             _status.set(a.message);
             _status_brush.set(a.category.fill);
             await Task.Delay(TimeSpan.FromSeconds(5));
@@ -138,7 +174,7 @@ namespace mbts.spark {
       public double open => _open.Value;
       public double settlement => _settlement.Value;
       public ulong volume => _volume.Value;
-      public bool revert { get => _revert.Value; set => _revert.set(value); }
+      public bool auto_clear { get => _auto_clear.Value; set => _auto_clear.set(value); }
       public CalculatorLogic size_calculator { get; }
       public OrderPropertiesEditorVM order_properties_vm { get; }
       public ObservableCollection<LadderOrderVM> orders { get; }
@@ -152,7 +188,6 @@ namespace mbts.spark {
       public Brush ask_foreground => _ask_foreground.Value;
       public DialogCommand settings_command { get; }
       internal LadderModel model => _model;
-      internal IReadOnlyDictionary<uint, OrderRecordImmutable> orders_cache { get; private set; } = new Dictionary<uint, OrderRecordImmutable>();
       internal IObservable<LadderSettings> settings => _settings_manager.subscribe_current();
 
       public LadderSettings get_save_state() {
@@ -195,16 +230,8 @@ namespace mbts.spark {
                
             uint size = args.size_from_alternate ? s.alternate_order_size : (uint)Math.Abs(size_calculator.value.Value);
             await _model.order_gateway.send_order(order, args.price, size);
-            if (revert) {
-               size_calculator.value = s.size;
-               if (order_properties_vm.selected_time_in_force != s.default_time_in_force && order_properties_vm.time_in_forces.Contains(s.default_time_in_force))
-                  order_properties_vm.selected_time_in_force = s.default_time_in_force;
-               foreach (var ot in order_properties_vm.order_types) {
-                  ot.load_from(_model.order_gateway.factory.custom_order(ot.order_type));
-                  if (ot.order_type == s.default_order_type)
-                     order_properties_vm.selected_order_type = ot;
-               }
-            }
+            if (auto_clear)
+               size_calculator.value = 0;
          }
       }
 

src/client/spark/view/Spark/Ladder/LadderView.xaml

@@ -227,6 +227,41 @@
           </Setter.Value>
         </Setter>
       </Style>
+      <Style x:Key="SettingsButton" TargetType="Button" BasedOn="{StaticResource LadderMenuButton}">
+        <Setter Property="Content">
+          <Setter.Value>
+            <TextBlock VerticalAlignment="Center">Settings</TextBlock>
+          </Setter.Value>
+        </Setter>
+        <Setter Property="Template">
+          <Setter.Value>
+            <ControlTemplate TargetType="Button">
+              <Border 
+                x:Name="Border"
+                BorderThickness="{TemplateBinding BorderThickness}"
+                BorderBrush="{mbts:BTSColor UI.Button.normal_border}"
+                Background="{mbts:BTSColor UI.Button.normal_background}"
+                Padding="{TemplateBinding Padding}"
+                SnapsToDevicePixels="True"
+                VerticalAlignment="Bottom"
+                Margin="0,0,0,12">
+                <ContentPresenter 
+                  HorizontalAlignment="Center"
+                  VerticalAlignment="Center"
+                  RecognizesAccessKey="True"
+                  Name="button_content" 
+                  />
+              </Border>
+              <ControlTemplate.Triggers>
+                <Trigger Property="IsMouseOver" Value="True">
+                  <Setter TargetName="Border" Property="Background" Value="{mbts:BTSColor UI.Button.mouseover_background}" />
+                  <Setter TargetName="Border" Property="BorderBrush" Value="{mbts:BTSColor UI.Button.mouseover_border}" />
+                </Trigger>
+              </ControlTemplate.Triggers>
+            </ControlTemplate>
+          </Setter.Value>
+        </Setter>
+      </Style>
     </ResourceDictionary>
   </UserControl.Resources>
   <AdornerDecorator>
@@ -359,7 +394,7 @@
         </ItemsControl>
         <Button Margin="2" HorizontalAlignment="Stretch" Command="{Binding size_calculator.clear}">Clear</Button>
         <!-- reset to defaults after order -->
-        <CheckBox Margin="2" IsChecked="{Binding revert}">Auto Clear</CheckBox>
+        <CheckBox Margin="2" IsChecked="{Binding auto_clear}">Auto Clear</CheckBox>
       </StackPanel>
       <Grid Grid.Row="1">
         <Grid.RowDefinitions>
@@ -371,16 +406,7 @@
           <Button Command="{Binding cancel_command}" CommandParameter="Asks" Style="{StaticResource CancelSells}"/>
           <Button Command="{Binding cancel_command}" CommandParameter="All" Style="{StaticResource CancelAll}"/>
         </StackPanel>
-        <Button Grid.Row="1" HorizontalContentAlignment="Stretch" VerticalAlignment="Bottom" Margin="5,12,5,16" Command="{Binding settings_command}" Padding="4,0" Style="{StaticResource LadderMenuButton}" ToolTip="Settings">
-          <Grid HorizontalAlignment="Stretch">
-            <Grid.ColumnDefinitions>
-              <ColumnDefinition Width="Auto"/>
-              <ColumnDefinition/>
-            </Grid.ColumnDefinitions>
-            <Image Height="15" SnapsToDevicePixels="True" VerticalAlignment="Center" HorizontalAlignment="Left" Stretch="Uniform" Source="{x:Static mbts:Icons.ViewSettings}" RenderOptions.BitmapScalingMode="HighQuality"/>
-            <TextBlock Grid.Column="1" VerticalAlignment="Center" Margin="6,2">Settings</TextBlock>
-          </Grid>
-        </Button>
+        <Button Grid.Row="1" HorizontalContentAlignment="Stretch" Command="{Binding settings_command}" Style="{StaticResource SettingsButton}" />
       </Grid>
     </Grid>
     <Border Grid.Column="2" HorizontalAlignment="Stretch">
@@ -422,15 +448,9 @@
           <Setter Property="FontFamily" Value="{Binding font_family}"/>
           <Setter Property="FontSize" Value="{Binding font_size}"/>
           <Setter Property="Foreground" Value="{Binding foreground}"/>
-          <Setter Property="Text" Value="{Binding text}" />
-          <Setter Property="TopText" Value="{Binding top_line}" />
-          <Setter Property="BottomText" Value="{Binding bottom_line}" />
-          <Setter Property="BorderThickness" Value="2" />
-          <Setter Property="Width" Value="63" />
-          <Setter Property="Height" Value="23" />
-          <Setter Property="Margin" Value="4,0,0,0" />
+          <Setter Property="TextLines" Value="{Binding text_lines}" />
+          <Setter Property="Width" Value="{x:Static controls:Badge.DefaultWidth}"/>
           <Setter Property="ToolTip" Value="{Binding description}" />
-          <Setter Property="CornerRadius" Value="1" />
           <Setter Property="Cursor" Value="Hand"/>
           <Setter Property="ContextMenu">
             <Setter.Value>
@@ -481,4 +501,4 @@
     </Button>
   </Grid>
   </AdornerDecorator>
-</UserControl>
+</UserControl>

src/client/spark/view/Spark/Ladder/LaderRender.cs

@@ -1,20 +1,61 @@
 using bts.api;
 using mbts.co2;
 using mbts.ui;
+using mbts.ui.controls;
 using mbts.ui.utility.text;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Media;
 
 namespace mbts.spark {
+   static class BadgeRender {
+      // IMPORTANT: the return values for this method MUST BE IN SYNC with the "format" method, else "measure_height" and "LadderRender.measure_row_height" will be broken.
+      static int _line_count_for_style(LadderSettings.BadgeStyle badge_style) => badge_style == LadderSettings.BadgeStyle.Alternate ? 2 : 1;
+      // IMPORTANT: at the risk of being redundant, see above comment.
+      public static IReadOnlyList<string> format(Side side, uint quantity, uint filled, LadderSettings.BadgeStyle style) {
+         switch (style) {
+            case LadderSettings.BadgeStyle.Alternate:
+               return new[] {
+                  $"{side.abbreviate()}:{filled}",
+                  $"W:{quantity - filled}"
+               };
+            default: return new[] { $"{filled}/{quantity}" };
+         }
+      }
+
+      public static double measure_height(LadderSettings.BadgeStyle badge_style, Thickness border_thickness, Thickness padding, double font_size) =>
+         measure_height(_line_count_for_style(badge_style), border_thickness, padding, font_size);
+
+      public static double measure_height(int line_count, Thickness border_thickness, Thickness padding, double font_size) =>
+         WPFHelper.control_base_height(border_thickness, padding) + font_size * line_count + Badge.LINE_SPACING * (line_count - 1);
+   }
+
    static class LadderRender {
+      // Note: the orders-column has a separate "row_padding" value: Badge.DefaultMargin
+      // (see how it is incorporated in measure_row_height() below)
+      public static readonly Thickness row_padding = new Thickness(6);
+
+      // IMPORTANT: this method ONLY WORKS if Badges use the BadgeRender.margin/border_thickness/padding values.
+      // TODO: elminate the dependency on BadgeRender.margin/border_thickness/padding by integrating them into settings.
+      public static double measure_row_height(LadderSettings settings) =>
+         Math.Max(new[] {
+            settings.bid_column.font_size,
+            settings.price_column.font_size,
+            settings.ask_column.font_size,
+            settings.last_column.font_size
+         }.Max() + row_padding.Top + row_padding.Bottom,
+        BadgeRender.measure_height(
+           settings.badge_style, Badge.DefaultBorderThickness, Badge.DefaultPadding, settings.orders_column.font_size
+         ) + Badge.DefaultMargin.Top + Badge.DefaultMargin.Bottom);
+
       public static int index_of(double[] prices, double price, IComparer<double> comparer) =>
          Array.BinarySearch(prices, price, comparer);
 
       public static GlyphRun format_text(string text, int row, double row_height, LadderColumnSettings settings, GlyphContext glyph_context) =>
-         glyph_context.get_glyph_run(text, settings.font_size, settings.width, row_height, HorizontalAlignment.Center, 0, VerticalAlignment.Center, row * row_height);
+         glyph_context.get_glyph_run(text, settings.font_size, settings.width, row_height, HorizontalAlignment.Center, 0, VerticalAlignment.Center, row * row_height, true);
 
       public static double[] gen_prices(double mid, int row_count, ContractSpecificationImmutable spec) {
          // require odd number

src/client/spark/view/Spark/Ladder/RecenterCountdown.cs

@@ -17,16 +17,17 @@ namespace mbts.spark {
       };
       SecurityImmutable? _security;
       MDConsumerHandle _handle;
-      LadderSettings _settings;
       DateTime _last_recenter = DateTime.MaxValue;
       double _last_mid = 0.0;
       IDisposable _dispose;
+      readonly TimeSpan _seconds_to_center;
 
       public RecenterCountdown() {
          DataContextChanged += RecenterCountdown_DataContextChanged;
          Unloaded += (o,e) => on_unload(false);
          _timer.Tick += _timer_Tick;
          _timer.Start();
+         _seconds_to_center = TimeSpan.FromSeconds(config.Configuration.get<bts.config.LadderKnobs>().seconds_to_recenter);
       }
 
       static (double,double) tick_range(double price, int tick_count, ContractSpecificationImmutable spec) {
@@ -34,11 +35,10 @@ namespace mbts.spark {
       }
 
       private void _timer_Tick(object sender, EventArgs e) {
-         if (_settings != null && _security != null) {
+         if (_security != null) {
             var mid = _handle.mid();
-            (double low, double high) = tick_range(_last_mid, _settings.ticks_to_recenter, _security.Value.ContractSpec);
             if (//mid < low || mid > high ||
-               (_last_recenter + TimeSpan.FromSeconds(_settings.seconds_to_recenter) < DateTime.UtcNow)) {
+               (_last_recenter + _seconds_to_center < DateTime.UtcNow)) {
                trigger_recenter(mid);
             }
          }
@@ -59,7 +59,6 @@ namespace mbts.spark {
             vm.OnDisposed += on_unload;
             _dispose =
                Disposable.Create(
-                  vm.settings.Subscribe(s => _settings = s),
                   Disposable.Create(() => vm.OnDisposed -= on_unload));
          }
       }

src/client/spark/view/Spark/PAndL/PAndLModel.cs

@@ -1,14 +1,9 @@
 using bts.api;
+using mbts.utils;
 using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.ComponentModel.Composition;
-using System.Linq;
-using System.Reactive.Linq;
-using System.Threading.Tasks;
 
-namespace mbts.spark
-{
+namespace mbts.spark {
    [Export]
    class PAndLModel : IDisposable {
       readonly IBus _bus;
@@ -23,19 +18,8 @@ namespace mbts.spark
          //_account_service = account_service;
       }
 
-      public IObservable<List<PnLData>> on_pnl_data =>
-         // combine w/ Securities to get SecurityMD
-         _order_model.on_fill_tuples.CombineLatest(_bus.subscribe(SparkTags.SecuritiesTag), (fills, securities) => {
-            List<PnLData> pnl_data = new List<PnLData>(fills.state.Count);
-            foreach (var ft in fills.state.Values) {
-               if (ft.security.HasValue && securities.TryGetValue(ft.security.Value.Id, out SecurityMD sec_md)) {
-                  pnl_data.Add(new PnLData(ft.fill, sec_md, ft.order));
-               } else {
-                  pnl_data.Add(new PnLData(ft.fill, null, ft.order));
-               }
-            }
-            return pnl_data;
-         });
+      public IObservable<ITableUpdateTransform<PnLData, FillTupleKey>> on_pnl_data =>
+         _order_model.on_fill_tuples.convert(ft => new PnLData(ft)).table(pd => pd.key);
 
       //public async Task<Account[]> get_accounts() {
       //   var request = await _account_service.get_accounts_async(new GetAccountsRequest());
@@ -45,12 +29,8 @@ namespace mbts.spark
       //   }
       //   return new Account[] { };
       //}
-
       
       public void Dispose() =>
          Disposable.dispose(ref _dispose);
-
    }
-
-
-}
+}

src/client/spark/view/Spark/PAndL/PAndLVM.cs

@@ -20,10 +20,10 @@ namespace mbts.spark {
          _model = model;
          var pnl = model.on_pnl_data
             .Sample(_POSITION_UPDATE_PERIOD)
-            .ObserveOnDispatcher()
+            .OnDispatcher()
             .Subscribe(p => {
                if (p != null) {
-                  PnLCalculator calc = new PnLCalculator(p);
+                  PnLCalculator calc = new PnLCalculator(p.state.Values);
                   var summary_position_rows = calc.get_summary_position();
                   _pnl_data.sync_with(summary_position_rows);
                   _last_pnl_update_time = DateTime.Now;

src/client/spark/view/Spark/PAndL/PnLCalculator.cs

@@ -76,9 +76,9 @@ namespace mbts.spark {
 
 
    class PnLCalculator {
-      readonly List<PnLData> _data;
+      readonly IEnumerable<PnLData> _data;
 
-      public PnLCalculator(List<PnLData> data) {
+      public PnLCalculator(IEnumerable<PnLData> data) {
          _data = data;
       }
 

src/client/spark/view/Spark/PAndL/PnLData.cs

@@ -1,11 +1,6 @@
 using bts.api;
 using bts.api.orderman;
-using mbts.co2;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace mbts.spark {
 
@@ -23,16 +18,16 @@ namespace mbts.spark {
 
    class PnLData {
       
-      public readonly FillImmutable fill;
-      public readonly SecurityMD? sec_md;
-      public readonly OrderRecordImmutable? order;
+      readonly FillTuple _fill_tuple;
 
-      public PnLData(FillImmutable fill, SecurityMD? sec_md, OrderRecordImmutable? order) {
-         this.fill = fill;
-         this.sec_md = sec_md;
-         this.order = order;
-      }
+      public PnLData(FillTuple fill_tuple) =>
+         _fill_tuple = fill_tuple;
 
+      public FillTupleKey key => _fill_tuple.key;
+      public FillImmutable fill => _fill_tuple.fill;
+      public SecurityMD? sec_md => _fill_tuple.security_md;
+      public OrderRecordImmutable? order => _fill_tuple.order;
+      //
       public string account => order?.Def.Account;
       public Venue? exchange => sec_md?.security.Exchange;
       public string symbol => sec_md?.security.Symbol;
@@ -43,7 +38,5 @@ namespace mbts.spark {
       public override string ToString() {
          return $"Fill: ( {account} {exchange} {security.ToString()} buy: {buy_quantity} sell: {sell_quantity} ) Security: {security.ToString()}";
       }
-
-
    }
-}
+}

src/client/spark/view/Spark/Shell/CVOrderBook/CVOrderBookCell.cs

@@ -5,92 +5,153 @@ using System.ComponentModel;
 
 namespace mbts.spark {
    partial class CVOrderBookRowVM {
-      public interface IOrderBookCell : IComparable, INotifyPropertyChanged {
+      public interface IOrderBookCell : IComparable {
          string text { get; }
+      }
+
+      public interface IOrderBookCell<T> : IOrderBookCell {
+         T value { get; }
+         IOrderBookCellStore<T> store { get; }
+      }
+
+      public interface IOrderBookCellStore {
+         CVOrderBookRowVM row { get; }
+         ICVOrderBookColumn column { get; }
+         string prop_name { get; }
+         IOrderBookCell current { get; }
+         //
+         IOrderBookCellStore select_other(CVOrderBookRowVM row);
          bool refresh();
+         void regenerate_cell();
+      }
+
+      public interface IOrderBookCellStore<T> : IOrderBookCellStore, IComparer<T>, IEqualityComparer<T> {
+         new IOrderBookCell<T> current { get; }
+         new IOrderBookCellStore<T> select_other(CVOrderBookRowVM row);
+         //
+         T get_value(CVOrderBookRowVM row);
+         string format(T value);
       }
 
       public static class CellFactory {
-         public static OrderBookCell<T> create<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, Func<CVOrderBookRowVM, T> get_value, Func<CVOrderBookRowVM, OrderBookCell<T>> get_cell, Func<T, string> format = null) =>
-           new OrderBookCell<T>(row, column, get_value, get_cell, format, new Comparison<T>(Comparer<T>.Default.Compare), EqualityComparer<T>.Default);
+         public static IOrderBookCellStore<T> create<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, string prop_name, Func<CVOrderBookRowVM, T> get_value, Func<CVOrderBookRowVM, IOrderBookCellStore<T>> select_other, Func<T, string> format = null) =>
+            new OrderBookCellStore<T>(row, column, prop_name, get_value, select_other, format, new Comparison<T>(Comparer<T>.Default.Compare), EqualityComparer<T>.Default);
 
-         public static OrderBookCell<T> create<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, Func<CVOrderBookRowVM, T> get_value, Func<CVOrderBookRowVM, OrderBookCell<T>> get_cell, Comparison<T> comparison, Func<T, string> format = null) =>
-            new OrderBookCell<T>(row, column, get_value, get_cell, format, comparison, EqualityComparer<T>.Default);
+         public static IOrderBookCellStore<T> create<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, string prop_name, Func<CVOrderBookRowVM, T> get_value, Func<CVOrderBookRowVM, IOrderBookCellStore<T>> select_other, Comparison<T> comparison, Func<T, string> format = null) =>
+            new OrderBookCellStore<T>(row, column, prop_name, get_value, select_other, format, comparison, EqualityComparer<T>.Default);
 
-         public static OrderBookCell<T?> create_nullable<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, Func<CVOrderBookRowVM, T?> get_value, Func<CVOrderBookRowVM, OrderBookCell<T?>> get_cell, Func<T?, string> format = null)
-            where T : struct => new OrderBookCell<T?>(row, column, get_value, get_cell, format, CompareUtils.nullable_comparison<T>(Comparer<T>.Default.Compare), EqualityComparer.CreateNullable<T>(EqualityComparer<T>.Default.Equals));
+         public static IOrderBookCellStore<T?> create_nullable<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, string prop_name, Func<CVOrderBookRowVM, T?> get_value, Func<CVOrderBookRowVM, IOrderBookCellStore<T?>> select_other, Func<T?, string> format = null)
+            where T : struct => new OrderBookCellStore<T?>(row, column, prop_name, get_value, select_other, format, CompareUtils.nullable_comparison<T>(Comparer<T>.Default.Compare), EqualityComparer.CreateNullable<T>(EqualityComparer<T>.Default.Equals));
 
-         public static OrderBookCell<T?> create_nullable<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, Func<CVOrderBookRowVM, T?> get_value, Func<CVOrderBookRowVM, OrderBookCell<T?>> get_cell, Func<T, T, int> compare, Func<T?, string> format = null)
-            where T : struct => new OrderBookCell<T?>(row, column, get_value, get_cell, format, CompareUtils.nullable_comparison(compare), EqualityComparer.CreateNullable<T>(EqualityComparer<T>.Default.Equals));
-      }
+         public static IOrderBookCellStore<T?> create_nullable<T>(CVOrderBookRowVM row, ICVOrderBookColumn column, string prop_name, Func<CVOrderBookRowVM, T?> get_value, Func<CVOrderBookRowVM, IOrderBookCellStore<T?>> select_other, Func<T, T, int> compare, Func<T?, string> format = null)
+            where T : struct =>
+            new OrderBookCellStore<T?>(row, column, prop_name, get_value, select_other, format, CompareUtils.nullable_comparison(compare), EqualityComparer.CreateNullable<T>(EqualityComparer<T>.Default.Equals));
 
-      public class OrderBookCell<T> : IComparable<OrderBookCell<T>>, IOrderBookCell {
-         readonly CVOrderBookRowVM _row;
-         readonly ICVOrderBookColumn _column;
-         readonly Func<CVOrderBookRowVM, T> _get_value;
-         readonly Func<CVOrderBookRowVM, OrderBookCell<T>> _get_cell;
-         readonly Func<T, string> _format;
-         readonly Comparison<T> _comparison;
-         readonly IEqualityComparer<T> _eq_comparer;
-         T _value;
-         string _text;
+         class OrderBookCellStore<T> : IOrderBookCellStore<T> {
+            readonly CVOrderBookRowVM _row;
+            readonly ICVOrderBookColumn _column;
+            readonly string _prop_name;
+            readonly Func<CVOrderBookRowVM, T> _get_value;
+            readonly Func<CVOrderBookRowVM, IOrderBookCellStore<T>> _select_other;
+            readonly Func<T, string> _format;
+            readonly Comparison<T> _comparison;
+            readonly IEqualityComparer<T> _eq_comparer;
+            OrderBookCell<T> _current;
 
-         public OrderBookCell(CVOrderBookRowVM row, ICVOrderBookColumn column, Func<CVOrderBookRowVM, T> get_value, Func<CVOrderBookRowVM, OrderBookCell<T>> get_cell, Func<T, string> format, Comparison<T> comparison, IEqualityComparer<T> eq_comparer) {
-            _row = row;
-            _column = column;
-            _get_value = get_value;
-            _get_cell = get_cell;
-            _format = format ?? new Func<T, string>(v => v?.ToString() ?? string.Empty);
-            _comparison = comparison;
-            _eq_comparer = eq_comparer;
-            _value = _get_value(_row);
-         }
+            public OrderBookCellStore(
+              CVOrderBookRowVM row,
+              ICVOrderBookColumn column,
+              string prop_name,
+              Func<CVOrderBookRowVM, T> get_value,
+              Func<CVOrderBookRowVM, IOrderBookCellStore<T>> select_other,
+              Func<T, string> format,
+              Comparison<T> comparison,
+              IEqualityComparer<T> eq_comparer) {
+               //
+               _row = row;
+               _column = column;
+               _prop_name = prop_name;
+               _get_value = get_value;
+               _select_other = select_other;
+               _format = format ?? new Func<T, string>(v => v?.ToString() ?? string.Empty);
+               _comparison = comparison;
+               _eq_comparer = eq_comparer;
+               _current = new OrderBookCell<T>(this, _get_value(_row));
+            }
 
-         public event PropertyChangedEventHandler PropertyChanged;
+            public CVOrderBookRowVM row => _row;
+            public ICVOrderBookColumn column => _column;
+            public string prop_name => _prop_name;
+            public IOrderBookCell<T> current => _current;
+            IOrderBookCell IOrderBookCellStore.current => _current;
 
-         public T value => _value;
-         public string text => _text ?? (_text = _format(_value));
+            public int Compare(T x, T y) => _comparison(x, y);
+            public bool Equals(T x, T y) => _eq_comparer.Equals(x, y);
+            public string format(T value) => _format(value);
+            public int GetHashCode(T obj) => _eq_comparer.GetHashCode(obj);
+            public T get_value(CVOrderBookRowVM row) => _get_value(row);
+            public IOrderBookCellStore<T> select_other(CVOrderBookRowVM row) => _select_other(row);
+            IOrderBookCellStore IOrderBookCellStore.select_other(CVOrderBookRowVM row) => select_other(row);
 
-         public bool refresh() {
-            var v = _get_value(_row);
-            if (!_eq_comparer.Equals(v, _value)) {
-               _value = v;
-               _text = null;
-               PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(value)));
-               PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(text)));
-               return true;
+            public bool refresh() {
+               T v = _get_value(_row);
+               if (!_eq_comparer.Equals(v, _current.value)) {
+                  _current = new OrderBookCell<T>(this, v);
+                  _row.RaisePropertyChanged(_prop_name);
+                  return true;
+               } else return false;
+            }
+
+            public void regenerate_cell() {
+               _current = new OrderBookCell<T>(this, _current.value);
+               _row.RaisePropertyChanged(_prop_name);
             }
-            return false;
          }
 
-         public int CompareTo(OrderBookCell<T> other) {
-            if (other == null)
-               return 1;
-            var lin = lineage(_row);
-            var olin = lineage(other._row);
-            int c = 0;
-            using (var en = lin.GetEnumerator())
-            using (var oen = olin.GetEnumerator()) {
-               while (en.MoveNext() && oen.MoveNext()) {
-                  if (en.Current.order_key.value != oen.Current.order_key.value) {
-                     c = _comparison(_get_cell(en.Current).value, _get_cell(oen.Current).value);
-                     if (c != 0)
-                        return c;
-                     else {
-                        c = en.Current.order_key.value.CompareTo(oen.Current.order_key.value);
-                        return _column.SortDirection.HasValue && _column.SortDirection.Value == ListSortDirection.Ascending ? c : -c;
+         class OrderBookCell<T> : IOrderBookCell<T> {
+            string _text;
+
+            public OrderBookCell(OrderBookCellStore<T> store, T value) {
+               this.store = store;
+               this.value = value;
+            }
+
+            public string text => _text ?? (_text = store.format(value));
+            public T value { get; }
+            public IOrderBookCellStore<T> store { get; }
+
+            public int CompareTo(OrderBookCell<T> other) {
+               if (other == null)
+                  return 1;
+               var lin = lineage(store.row);
+               var olin = lineage(other.store.row);
+               int c = 0;
+               using (var en = lin.GetEnumerator())
+               using (var oen = olin.GetEnumerator()) {
+                  while (en.MoveNext() && oen.MoveNext()) {
+                     if (en.Current.order_key.value != oen.Current.order_key.value) {
+                        c = store.Compare(
+                           store.select_other(en.Current).current.value,
+                           store.select_other(oen.Current).current.value);
+                        if (c != 0)
+                           return c;
+                        else {
+                           c = en.Current.order_key.value.CompareTo(
+                              oen.Current.order_key.value);
+                           return store.column.SortDirection.HasValue && store.column.SortDirection.Value == ListSortDirection.Ascending ? c : -c;
+                        }
                      }
                   }
                }
+               return store.column.SortDirection.HasValue && store.column.SortDirection.Value == ListSortDirection.Ascending ?
+                  lin.Count.CompareTo(olin.Count) :
+                  olin.Count.CompareTo(lin.Count);
             }
-            return _column.SortDirection.HasValue && _column.SortDirection.Value == ListSortDirection.Ascending ?
-               lin.Count.CompareTo(olin.Count) : olin.Count.CompareTo(lin.Count);
+
+            public int CompareTo(object obj) => CompareTo(obj as OrderBookCell<T>);
+
+            public override string ToString() => text;
          }
-
-         public int CompareTo(object obj) =>
-            CompareTo(obj as OrderBookCell<T>);
-
-         public override string ToString() => text;
       }
    }
 }

src/client/spark/view/Spark/Shell/CVOrderBook/CVOrderBookColumns.cs

@@ -34,14 +34,15 @@ namespace mbts.spark {
    // TODO: Maybe binding to the SortDirection would be less smelly?
    //    - initially, I tried to bind to the SortDirection of each column, unfortunately, the binding target was not updated before the ICollectionView sorting took place.
    //      I decided it was not worth changing the DIYGrid.Sorting function to force the SortDirection binding targets to update immediately, before the ICollectionView sorting.
-   interface ICVOrderBookColumn {
+   interface ICVOrderBookColumn : IKeyedColumn<Columns> {
+      string sort_member_path { get; }
       ListSortDirection? SortDirection { get; }
       IDataGridColumnFilter<CVOrderBookRowVM> filter { get; }
    }
 
    partial class CVOrderBookVM {
       public class CVOrderBookColumnCollection : ObservableCollection<ColumnBase>, IDisposable {
-         public CVOrderBookColumnCollection(IBus bus, OrdersModel model, OrderBookStartupData startup_data, IObservable<(IReadOnlyList<SecurityImmutable> added, IReadOnlyList<SecurityImmutable> removed)> order_securities) {
+         public CVOrderBookColumnCollection(IBus bus, OrdersModel model, OrderBookStartupData startup_data, IObservable<(IEnumerable<SecurityImmutable> added, IEnumerable<SecurityImmutable> removed)> order_securities) {
             // security
             Add(security_column = new SecurityColumn(this,
                DiscreteValuesFilterVM.Create<CVOrderBookRowVM, SecurityImmutable, SecurityCriteria>(
@@ -200,7 +201,7 @@ namespace mbts.spark {
                DataGridFilterKnownTemplates.Regex));
 
             string value_path(string cell_name) =>
-               string.Join(".", cell_name, nameof(CVOrderBookRowVM.OrderBookCell<uint>.value)); //uint is an arbitrary 'T', just want to get compile check on 'value' path.
+               string.Join(".", cell_name, nameof(CVOrderBookRowVM.IOrderBookCell<uint>.value)); //uint is an arbitrary 'T', just want to get compile check on 'value' path.
 
             if (startup_data?.filters is FilterStates fs) {
                security_column.filter.load_state(fs.security_criteria);
@@ -317,7 +318,10 @@ namespace mbts.spark {
          string IFilterableColumn.filter_template => _filter_template;
          ListSortDirection? ICVOrderBookColumn.SortDirection => _cached_sort_direction;
 
-         protected override void OnSortDirectionChanged(ListSortDirection? new_value) => _cached_sort_direction = new_value;
+         protected override void OnSortDirectionChanged(ListSortDirection? new_value) {
+            _cached_sort_direction = new_value;
+            base.OnSortDirectionChanged(new_value);
+         }
       }
 
       public class SimpleTextColumn<TFilterState> : OrderbookColumnBase<TFilterState>, IRenderColumn<CVOrderBookRowVM> {
@@ -414,7 +418,7 @@ namespace mbts.spark {
       public class OrderBookOrderTypeColumn : OrderTypeColumn<Columns>, ICVOrderBookColumn {
          ListSortDirection? _cached_sort_direction;
          public OrderBookOrderTypeColumn(IDataGridColumnPersistentFilter<CVOrderBookRowVM, OrderType[]> filter)
-            : base(Columns.OrderType, new Binding($"{nameof(CVOrderBookRowVM.order_type)}.{nameof(CVOrderBookRowVM.OrderBookCell<OrderType>.value)}"), new Binding(nameof(CVOrderBookRowVM.order_metadata)), filter) {
+            : base(Columns.OrderType, new Binding($"{nameof(CVOrderBookRowVM.order_type)}.{nameof(CVOrderBookRowVM.IOrderBookCell<OrderType>.value)}"), new Binding(nameof(CVOrderBookRowVM.order_metadata)), filter) {
             this.filter = filter;
             sort_member_path = nameof(CVOrderBookRowVM.order_type);
             font_weight_binding = RenderUtils.get_font_weight_binding();
@@ -426,14 +430,17 @@ namespace mbts.spark {
          IDataGridColumnFilter<CVOrderBookRowVM> ICVOrderBookColumn.filter => filter;
          ListSortDirection? ICVOrderBookColumn.SortDirection => _cached_sort_direction;
 
-         protected override void OnSortDirectionChanged(ListSortDirection? new_value) => _cached_sort_direction = new_value;
+         protected override void OnSortDirectionChanged(ListSortDirection? new_value) {
+            _cached_sort_direction = new_value;
+            base.OnSortDirectionChanged(new_value);
+         }
       }
 
       public class OrderBookLastMessageColumn : TextColumn<Columns>, ICVOrderBookColumn {
          ListSortDirection? _cached_sort_direction;
 
          public OrderBookLastMessageColumn(IDataGridColumnPersistentFilter<CVOrderBookRowVM, string> filter)
-            : base(Columns.LastMessage, new Binding(nameof(CVOrderBookRowVM.last_msg)), filter, DataGridFilterKnownTemplates.Regex) {
+            : base(Columns.LastMessage, new Binding($"{nameof(CVOrderBookRowVM.last_msg)}.{nameof(CVOrderBookRowVM.IOrderBookCell<string>.value)}"), filter, DataGridFilterKnownTemplates.Regex) {
             this.filter = filter;
             Header = "Last Message";
             Width = 80;
@@ -446,7 +453,10 @@ namespace mbts.spark {
          IDataGridColumnFilter<CVOrderBookRowVM> ICVOrderBookColumn.filter => filter;
          ListSortDirection? ICVOrderBookColumn.SortDirection => _cached_sort_direction;
 
-         protected override void OnSortDirectionChanged(ListSortDirection? new_value) => _cached_sort_direction = new_value;
+         protected override void OnSortDirectionChanged(ListSortDirection? new_value) {
+            _cached_sort_direction = new_value;
+            base.OnSortDirectionChanged(new_value);
+         }
       }
 
       public class SecurityColumn : FrameworkElementColumnBase<Columns>, ICVOrderBookColumn, IFilterableColumn {
@@ -480,7 +490,7 @@ namespace mbts.spark {
             toggle_button.SetResourceReference(ToggleButton.StyleProperty, ExpandCollapseToggleStyleKey);
             //
             var security_view = new TextBlock();
-            security_view.SetBinding(TextBlock.TextProperty, nameof(CVOrderBookRowVM.security));
+            security_view.SetBinding(TextBlock.TextProperty, $"{nameof(CVOrderBookRowVM.security)}.{nameof(CVOrderBookRowVM.IOrderBookCell<SecurityImmutable?>.text)}");
             security_view.SetBinding(TextBlock.FontWeightProperty, _font_weight_binding);
             //
             var grid = new Grid();
@@ -492,7 +502,10 @@ namespace mbts.spark {
             return grid;
          }
 
-         protected override void OnSortDirectionChanged(ListSortDirection? new_value) => _cached_sort_direction = new_value;
+         protected override void OnSortDirectionChanged(ListSortDirection? new_value) {
+            _cached_sort_direction = new_value;
+            base.OnSortDirectionChanged(new_value);
+         }
       }
       #endregion
 

src/client/spark/view/Spark/Shell/CVOrderBook/CVOrderBookRowVM.cs

@@ -5,23 +5,47 @@ using mbts.ui;
 using mbts.ui.shell;
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Reactive.Linq;
 using System.Windows.Input;
+using static mbts.spark.OrderBookView;
 using OrderStatus = bts.api.orderman.OrderStatus;
 
 namespace mbts.spark {
-   partial class CVOrderBookRowVM : ViewModelBase, IEquatable<CVOrderBookRowVM>, ui.controls.DIYGrid.IRowVM, ui.controls.DIYGrid.IActionableRowVM {
+   partial class CVOrderBookRowVM : DisposableViewModelBase, IEquatable<CVOrderBookRowVM>, ui.controls.DIYGrid.IRowVM, ui.controls.DIYGrid.IActionableRowVM {
       readonly CVOrderBookVM _book_vm;
       readonly OrdersModel _model;
-      readonly Property<bool> _visible, _expanded;
-      readonly DelegateProperty<bool> _passes_filter;
-      readonly HashSet<uint> _child_orders_pass_filter = new HashSet<uint>();
+      readonly Property<bool> _visible, _expanded, _passes_filter;
+      readonly DelegateProperty<int> _depth_level;
       readonly HashSet<CVOrderBookRowVM> _child_rows = new HashSet<CVOrderBookRowVM>();
       readonly ObservantCommand _show_order_modify_cmd;
       OrderRecordImmutable _order;
-      SecurityImmutable? _security; 
+      SecurityImmutable? _security;
       CVOrderBookRowVM _parent;
-      bool _row_passes_filter;
+      CVOrderBookVM.BranchFilterSource _branch_filter_source;
+      IDisposable _branch_filter_sub;
+      // Core
+      IOrderBookCellStore<uint> _order_key_store;
+      IOrderBookCellStore<uint> _parent_order_key_store;
+      IOrderBookCellStore<uint> _security_key_store;
+      IOrderBookCellStore<SecurityImmutable?> _security_store;
+      IOrderBookCellStore<Venue> _exchange_store;
+      // Def
+      IOrderBookCellStore<CustomOrderDefinition.CustomOneofCase> _order_type_store;
+      IOrderBookCellStore<Side> _side_store;
+      IOrderBookCellStore<string> _user_store;
+      IOrderBookCellStore<string> _account_store;
+      IOrderBookCellStore<TimeInForce> _time_in_force_store;
+      IOrderBookCellStore<DateTime> _time_created_store;
+      // State
+      IOrderBookCellStore<DateTime> _last_change_store { get; set; }
+      IOrderBookCellStore<OrderStatus> _status_store;
+      IOrderBookCellStore<double> _price_store;
+      IOrderBookCellStore<uint> _quantity_store;
+      IOrderBookCellStore<uint> _filled_quantity_store;
+      IOrderBookCellStore<double> _last_price_store;
+      IOrderBookCellStore<double> _avg_price_store;
+      IOrderBookCellStore<string> _last_msg_store;
+      IOrderBookCellStore<OrderSubType> _order_sub_type_store;
 
       public CVOrderBookRowVM(IBus bus, CVOrderBookVM source_vm, OrdersModel model, OrderRecordImmutable record, SecurityImmutable? s) {
          _book_vm = source_vm;
@@ -29,26 +53,26 @@ namespace mbts.spark {
          _order = record;
          _security = s;
          // cells
-         security = CellFactory.create_nullable(this, _book_vm.columns.security_column, r => r._security, r => r.security, v => v.HasValue ? v.Value.ToString() : "unknown security");
-         security_key = CellFactory.create(this, _book_vm.columns.security_key_column, r => r._order.security_key(), r => r.security_key);
-         parent_order_key = CellFactory.create(this, _book_vm.columns.parent_key_column, r => r._order.ParentKey, r => r.parent_order_key);
-         order_key = CellFactory.create(this, _book_vm.columns.order_key_column, r => r._order.Key, r => r.order_key);
-         time_created = CellFactory.create(this, _book_vm.columns.time_created_column, r => r._order.created(), r => r.time_created, format_date);
-         user = CellFactory.create(this, _book_vm.columns.user_column, r => _order.user(), r => r.user);
-         account = CellFactory.create(this, _book_vm.columns.account_column, r => r._order.account(), r => r.account);
-         exchange = CellFactory.create(this, _book_vm.columns.exchange_column, r => r._security.HasValue ? _security.Value.Exchange : Venue.Unset, r => r.exchange);
-         time_in_force = CellFactory.create(this, _book_vm.columns.time_in_force_column, r => r._order.time_in_force(), r => r.time_in_force);
-         order_type = CellFactory.create(this, _book_vm.columns.order_type_column, r => r._order.order_type(), r => r.order_type);
-         order_sub_type = CellFactory.create(this, _book_vm.columns.sub_type_column, r => r._order.sub_type(), r => r.order_sub_type, format_sub_type);
-         side = CellFactory.create(this, _book_vm.columns.side_column, r => r._order.side(), r => r.side);
-         last_change = CellFactory.create(this, _book_vm.columns.last_change_column, r => _order.last_change(), r => r.last_change, format_date);
-         price = CellFactory.create(this, _book_vm.columns.price_column, r => _order.price(), r => r.price, format_price);
-         quantity = CellFactory.create(this, _book_vm.columns.qty_column, r => _order.quantity(), r => r.quantity);
-         filled_quantity = CellFactory.create(this, _book_vm.columns.filled_qty_column, r => _order.filled(), r => r.filled_quantity);
-         avg_price = CellFactory.create(this, _book_vm.columns.avg_price_column, r => _order.avg_price(), r => r.avg_price, format_price);
-         last_price = CellFactory.create(this, _book_vm.columns.last_price_column, r => _order.last_price(), r => r.last_price, format_price);
-         status = CellFactory.create(this, _book_vm.columns.status_column, r => _order.status(), r => r.status);
-         last_msg = CellFactory.create(this, _book_vm.columns.last_message_column, r => _order.last_msg(), r => r.last_msg);
+         _security_store = CellFactory.create_nullable(this, _book_vm.columns.security_column, nameof(security), r => r._security, r => r._security_store, v => v.HasValue ? v.Value.ToString() : "unknown security");
+         _security_key_store = CellFactory.create(this, _book_vm.columns.security_key_column, nameof(security_key), r => r._order.security_key(), r => r._security_key_store);
+         _parent_order_key_store = CellFactory.create(this, _book_vm.columns.parent_key_column, nameof(parent_order_key), r => r._order.ParentKey, r => r._parent_order_key_store);
+         _order_key_store = CellFactory.create(this, _book_vm.columns.order_key_column, nameof(order_key), r => r._order.Key, r => r._order_key_store);
+         _time_created_store = CellFactory.create(this, _book_vm.columns.time_created_column, nameof(time_created), r => r._order.created(), r => r._time_created_store, format_date);
+         _user_store = CellFactory.create(this, _book_vm.columns.user_column, nameof(user), r => _order.user(), r => r._user_store);
+         _account_store = CellFactory.create(this, _book_vm.columns.account_column, nameof(account), r => r._order.account(), r => r._account_store);
+         _exchange_store = CellFactory.create(this, _book_vm.columns.exchange_column, nameof(exchange), r => r._security.HasValue ? _security.Value.Exchange : Venue.Unset, r => r._exchange_store);
+         _time_in_force_store = CellFactory.create(this, _book_vm.columns.time_in_force_column, nameof(time_in_force), r => r._order.time_in_force(), r => r._time_in_force_store);
+         _order_type_store = CellFactory.create(this, _book_vm.columns.order_type_column, nameof(order_type), r => r._order.order_type(), r => r._order_type_store);
+         _order_sub_type_store = CellFactory.create(this, _book_vm.columns.sub_type_column, nameof(order_sub_type), r => r._order.sub_type(), r => r._order_sub_type_store, format_sub_type);
+         _side_store = CellFactory.create(this, _book_vm.columns.side_column, nameof(side), r => r._order.side(), r => r._side_store);
+         _last_change_store = CellFactory.create(this, _book_vm.columns.last_change_column, nameof(last_change), r => _order.last_change(), r => r._last_change_store, format_date);
+         _price_store = CellFactory.create(this, _book_vm.columns.price_column, nameof(price), r => _order.price(), r => r._price_store, format_price);
+         _quantity_store = CellFactory.create(this, _book_vm.columns.qty_column, nameof(quantity), r => _order.quantity(), r => r._quantity_store);
+         _filled_quantity_store = CellFactory.create(this, _book_vm.columns.filled_qty_column, nameof(filled_quantity), r => _order.filled(), r => r._filled_quantity_store);
+         _avg_price_store = CellFactory.create(this, _book_vm.columns.avg_price_column, nameof(avg_price), r => _order.avg_price(), r => r._avg_price_store, format_price);
+         _last_price_store = CellFactory.create(this, _book_vm.columns.last_price_column, nameof(last_price), r => _order.last_price(), r => r._last_price_store, format_price);
+         _status_store = CellFactory.create(this, _book_vm.columns.status_column, nameof(status), r => _order.status(), r => r._status_store);
+         _last_msg_store = CellFactory.create(this, _book_vm.columns.last_message_column, nameof(last_msg), r => _order.last_msg(), r => r._last_msg_store);
          //
          string format_price(double v) => _security.HasValue ? _security.Value.ContractSpec.format(v) : v.ToString();
          string format_date(DateTime v) => $"{v:M/d} {v:h:mm:ss.fff tt}";
@@ -60,61 +84,73 @@ namespace mbts.spark {
             }
          }
          //
-         _visible = backing(nameof(is_visible), !_order.has_parent());
+         _visible = backing(nameof(is_visible), true);
          _expanded = backing(nameof(is_expanded), true);
-         _row_passes_filter = _book_vm.columns.filter(this);
-         _passes_filter = backing(nameof(passes_filter), () => {
-            if (_parent != null)
-               return _parent.passes_filter;
-            else return _row_passes_filter || _descendents(this).Any(r => r._row_passes_filter);
+         _depth_level = backing(nameof(depth_level), () => {
+            int i = 0;
+            var curr = this;
+            while (curr._parent != null) {
+               i++;
+               curr = curr._parent;
+            }
+            return i;
          });
          toggle_command = new DelegateCommand(() => is_expanded = !is_expanded);
          _show_order_modify_cmd = new ObservantCommand(() => bus.post(SparkTags.ShowModifyOrderTag, _order.Key));
          _show_order_modify_cmd.OnNext(status.value == OrderStatus.Working);
+         row_passes_filter = _book_vm.columns.filter(this);
+         _passes_filter = backing(nameof(passes_filter),
+            Observable.FromEvent<Action<IObservable<bool>>, IObservable<bool>>(
+               cb => _branch_filter_source_changed += cb, cb => _branch_filter_source_changed -= cb)
+         .SelectMany(o => o));
       }
- 
+
       public event Action invalidated;
+      event Action<IObservable<bool>> _branch_filter_source_changed;
 
       public OrderRecordImmutable order => _order;
-      // Core
-      public OrderBookCell<uint> order_key { get; }
-      public OrderBookCell<uint> parent_order_key { get; }
-      public OrderBookCell<uint> security_key { get; }
-      public OrderBookCell<SecurityImmutable?> security { get; }
-      public OrderBookCell<Venue> exchange { get; }
-      // Def
-      public OrderBookCell<CustomOrderDefinition.CustomOneofCase> order_type { get; }
-      public OrderBookCell<Side> side { get; }
-      public OrderBookCell<string> user { get; }
-      public OrderBookCell<string> account { get; }
-      public OrderBookCell<TimeInForce> time_in_force { get; }
-      public OrderBookCell<DateTime> time_created { get; }
-      // State
-      public OrderBookCell<DateTime> last_change { get; }
-      public OrderBookCell<OrderStatus> status { get; }
-      public OrderBookCell<double> price { get; }
-      public OrderBookCell<uint> quantity { get; }
-      public OrderBookCell<uint> filled_quantity { get; }
-      public OrderBookCell<double> last_price { get; }
-      public OrderBookCell<double> avg_price { get; }
-      public OrderBookCell<string> last_msg { get; }
-      public OrderBookCell<OrderSubType> order_sub_type { get; }
       public OrderMetadata order_metadata => _model.factory.get_metadata(order_type.value);
+      public CVOrderBookRowVM parent => _parent;
+      // Core
+      public IOrderBookCell<uint> order_key => _order_key_store.current;
+      public IOrderBookCell<uint> parent_order_key => _parent_order_key_store.current;
+      public IOrderBookCell<uint> security_key => _security_key_store.current;
+      public IOrderBookCell<SecurityImmutable?> security => _security_store.current;
+      public IOrderBookCell<Venue> exchange => _exchange_store.current;
+      // Def
+      public IOrderBookCell<CustomOrderDefinition.CustomOneofCase> order_type => _order_type_store.current;
+      public IOrderBookCell<Side> side => _side_store.current;
+      public IOrderBookCell<string> user => _user_store.current;
+      public IOrderBookCell<string> account => _account_store.current;
+      public IOrderBookCell<TimeInForce> time_in_force => _time_in_force_store.current;
+      public IOrderBookCell<DateTime> time_created => _time_created_store.current;
+      // State
+      public IOrderBookCell<DateTime> last_change => _last_change_store.current;
+      public IOrderBookCell<OrderStatus> status => _status_store.current;
+      public IOrderBookCell<double> price => _price_store.current;
+      public IOrderBookCell<uint> quantity => _quantity_store.current;
+      public IOrderBookCell<uint> filled_quantity => _filled_quantity_store.current;
+      public IOrderBookCell<double> last_price => _last_price_store.current;
+      public IOrderBookCell<double> avg_price => _avg_price_store.current;
+      public IOrderBookCell<string> last_msg => _last_msg_store.current;
+      public IOrderBookCell<OrderSubType> order_sub_type => _order_sub_type_store.current;
       // Commands
       public ICommand toggle_command { get; }
       ICommand ui.controls.DIYGrid.IActionableRowVM.default_command => _show_order_modify_cmd;
       // Accessories
-      public CVOrderBookRowVM parent_row => _parent;
       public bool is_parent => _child_rows.Count > 0;
       public bool is_child => _order.has_parent();
       public IReadOnlyCollection<CVOrderBookRowVM> child_orders => _child_rows;
+      public CVOrderBookVM.BranchFilterSource branch_filter_source => _branch_filter_source;
+      public bool passes_filter => _passes_filter.Value;
+      public bool row_passes_filter { get; private set; }
       public bool is_visible {
          get => _visible.Value;
          set {
             _visible.set(value);
             if (is_expanded) {
                foreach (var child_row in _child_rows)
-                  child_row._visible.set(value);
+                  child_row.is_visible = value;
             }
          }
       }
@@ -126,165 +162,34 @@ namespace mbts.spark {
                child_row.is_visible = value;
          }
       }
-      public int depth_level {
-         get {
-            int i = 0;
-            var curr = this;
-            while (curr._parent != null) {
-               i++;
-               curr = curr._parent;
-            }
-            return i;
-         }
-      }
-      public bool passes_filter => _passes_filter.Value;
-      public bool row_passes_filter {
-         get => _row_passes_filter;
-         set {
-            if (_row_passes_filter != value) {
-               _row_passes_filter = value;
-               if (value) {
-                  if (!passes_filter) {
-                     var root = root_node(this);
-                     root._passes_filter.refresh();
-                     foreach (var r in _descendents(root))
-                        r._passes_filter.refresh();
-                  }
-               } else if (passes_filter) {
-                  var root = root_node(this);
-                  if (!root._row_passes_filter && !_descendents(root).AtLeast(2, r => r._row_passes_filter )) {
-                     root._passes_filter.refresh();
-                     foreach (var r in _descendents(root))
-                        r._passes_filter.refresh();
-                  }
-               }
-            }
-         }
-      }
+      public int depth_level => _depth_level.Value;
 
       // '_dynamic_render_cells' are presented by 'RenderColumns,' and may change value during the lifetime of this row
       // Note: by instantiating all these cells inside a CellPropertyGroup, we can update all of them with a single call.
       // this reduces the risk of accidentally failing to update one of the cells, esp if we make changes to them down the road.
-      IEnumerable<IOrderBookCell> _dynamic_render_cells {
+      IEnumerable<IOrderBookCellStore> _dynamic_render_cells {
          get {
-            yield return last_change;
-            yield return price;
-            yield return quantity;
-            yield return filled_quantity;
-            yield return avg_price;
-            yield return last_price;
-            yield return status;
-            yield return last_msg;
+            yield return _last_change_store;
+            yield return _price_store;
+            yield return _quantity_store;
+            yield return _filled_quantity_store;
+            yield return _avg_price_store;
+            yield return _last_price_store;
+            yield return _status_store;
+            yield return _last_msg_store;
          }
       }
 
-      IEnumerable<IOrderBookCell> _security_dependent_cells {
+      IEnumerable<IOrderBookCellStore> _security_dependent_cells {
          get {
-            yield return security;
-            yield return exchange;
-            yield return price;
-            yield return avg_price;
-            yield return last_price;
+            yield return _security_store;
+            yield return _exchange_store;
+            yield return _price_store;
+            yield return _avg_price_store;
+            yield return _last_price_store;
          }
       }
 
-      public void add_child_order(CVOrderBookRowVM child_row) {
-         // we don't need to raise this every single time
-         if (_child_rows.Add(child_row) && _child_rows.Count == 1)
-            RaisePropertyChanged("is_parent");
-         child_row._parent = this;
-         child_row.RaisePropertyChanged(nameof(depth_level));
-         var root = root_node(this);
-         if (child_row.passes_filter) {
-            if (child_row._row_passes_filter)
-               _child_orders_pass_filter.Add(child_row._order.Key);
-            // if this row isn't currently passing the filter, update it and the rest of the branch
-            if (!passes_filter) {
-               _passes_filter.set(true);
-               // child_row and its descendents already know they passed failter
-               foreach (var row in _descendents_except_node(root, child_row))
-                  row._passes_filter.set(true);
-            }
-         }
-         // recursively updates 'live_sorting_props,' and 'is_visible' for child_row and descendents
-         child_row.on_parent_updated();
-         if (child_row.row_passes_filter && !root.passes_filter) {
-            root._passes_filter.Value = true;
-            foreach (var d in _descendents(this))
-               d._passes_filter.Value = true;
-         }
-      }
-
-      public void remove_child_order(CVOrderBookRowVM child_row) {
-         if (_child_rows.Remove(child_row) && _child_rows.Count == 0)
-            RaisePropertyChanged(nameof(is_parent));
-         if (child_row._row_passes_filter) {
-            _child_orders_pass_filter.Remove(child_row._order.Key);
-            _passes_filter.refresh();
-         }
-      }
-
-      /// <summary>
-      /// Raises PropertyChanged events for all live sorting properties, then calls parent_updated() on all descendents.
-      /// <para>Note: call this method when parent order is added, removed, or changed.</para>
-      /// </summary>
-      public void on_parent_updated() {
-         foreach (var p in _book_vm.live_sorting_props)
-            RaisePropertyChanged(p);
-         is_visible = _parent == null || _parent.is_visible && _parent.is_expanded;
-         foreach (var child_row in _child_rows)
-            child_row.on_parent_updated();
-      }
-
-      public void update_order(OrderRecordImmutable order) {
-         _order = order;
-         // use Count(), as opposed to Any(), to force it to iterate through all cells
-         if (_dynamic_render_cells.Count(c => c.refresh()) > 0)
-            invalidated?.Invoke();
-         _show_order_modify_cmd.OnNext(status.value == OrderStatus.Working);
-         _on_update();
-      }
-
-      public void update_security(SecurityImmutable security) {
-         _security = security;
-         // use Count(), as opposed to Any(), to force it to iterate through all cells
-         if (_security_dependent_cells.Count(c => c.refresh()) > 0)
-            invalidated?.Invoke();
-         _on_update();
-      }
-
-      void _on_update() {
-         foreach (var p in _book_vm.live_sorting_props)
-            RaisePropertyChanged(p);
-         foreach (var child_row in _child_rows)
-            child_row.on_parent_updated();
-         _row_passes_filter = _book_vm.columns.filter(this);
-         row_passes_filter = _book_vm.columns.filter(this);
-      }
-
-      public void refresh_row_passes_filter() =>
-         _row_passes_filter = _book_vm.columns.filter(this);
-
-      public void refresh_branch_passes_filter() {
-         _passes_filter.refresh();
-         foreach (var r in _descendents(this))
-            r._passes_filter.refresh();
-      }
-
-      public void on_filter_changed() =>
-         _passes_filter.refresh();
-
-      public bool Equals(CVOrderBookRowVM other) => other != null && other.order_key == order_key; 
-      public override bool Equals(object obj) => Equals(obj as CVOrderBookRowVM);
-      public override int GetHashCode() => (int)_order.Key;
-      public override string ToString() => $"{order_key} {last_change} {parent_order_key}";
-
-      public static CVOrderBookRowVM root_node(CVOrderBookRowVM node) {
-         while (node._parent != null)
-            node = node._parent;
-         return node;
-      }
-
       public static Stack<CVOrderBookRowVM> lineage(CVOrderBookRowVM node) {
          var rv = new Stack<CVOrderBookRowVM>();
          rv.Push(node);
@@ -293,16 +198,73 @@ namespace mbts.spark {
          return rv;
       }
 
-      static IEnumerable<CVOrderBookRowVM> _descendents_except_node(CVOrderBookRowVM root, CVOrderBookRowVM except) {
-         foreach (var child in root._child_rows) {
-            if (child == except)
-               continue;
-            yield return child;
-            foreach (var grand_child in _descendents(child))
-               yield return grand_child;
+      public void join_branch_filter_source(CVOrderBookVM.BranchFilterSource new_branch_filter_source) {
+         _branch_filter_source = new_branch_filter_source;
+         _branch_filter_source.set_row_passes_filter(_order.Key, row_passes_filter);
+         _branch_filter_source_changed?.Invoke(_branch_filter_source);
+         foreach (var child_row in _child_rows)
+            child_row.join_branch_filter_source(_branch_filter_source);
+      }
+
+      /// <summary>
+      /// Attaches the child-row to this row's branch-filter-source, and recursively refreshes sort/filter properties for the child and it's descendents.
+      /// </summary>
+      public void add_child_order(CVOrderBookRowVM child_row) {
+         if (_child_rows.Add(child_row) && _child_rows.Count == 1)
+            RaisePropertyChanged(nameof(is_parent));
+         child_row._parent = this;
+         // child orders that arrived in an earlier update use a temporary branch_filter_source
+         // need to tell _book_vm to remove the now-stale branch_filter_source.
+         if (child_row._branch_filter_source != null)
+            _book_vm.remove_branch_filter_root(child_row._order.Key);
+         // recursively updates 'live_sorting_props,' and 'is_visible' for child_row and descendents
+         child_row._on_lineage_changed();
+      }
+
+      public void remove_child_order(CVOrderBookRowVM child_row) {
+         if (_child_rows.Remove(child_row) && _child_rows.Count == 0)
+            RaisePropertyChanged(nameof(is_parent));
+      }
+
+      public void remove_parent(CVOrderBookVM.BranchFilterSource new_branch_filter_source) {
+         _parent = null;
+         join_branch_filter_source(new_branch_filter_source);
+         refresh_row_passes_filter();
+         foreach (var p in _book_vm.live_sorting_props)
+            RaisePropertyChanged(p);
+         _depth_level.refresh();
+         foreach (CVOrderBookRowVM child_row in _child_rows)
+            child_row._on_lineage_changed();
+      }
+
+      public void update_order(OrderRecordImmutable order) {
+         Logger.assert(order.ParentKey == _order.ParentKey, "Parent Keys can change?");
+         Logger.assert(order.Key == _order.Key, "Keys can change?");
+         _order = order;
+         _update_partial(_dynamic_render_cells);
+      }
+
+      public void update_security(SecurityImmutable security) {
+         _security = security;
+         _update_partial(_security_dependent_cells);
+      }
+
+      public void refresh_row_passes_filter() {
+         row_passes_filter = _book_vm.columns.filter(this);
+         if (_branch_filter_source != null) {
+            _branch_filter_source.set_row_passes_filter(_order.Key, row_passes_filter);
+         } else {
+            _passes_filter.set(row_passes_filter);
          }
       }
 
+      public bool Equals(CVOrderBookRowVM other) => other != null && other._order.Key == _order.Key;
+      public override bool Equals(object obj) => Equals(obj as CVOrderBookRowVM);
+      public override int GetHashCode() => (int)_order.Key;
+      public override string ToString() => $"{order_key} {last_change} {parent_order_key}";
+
+      protected override void Dispose(bool disposing) => Disposable.dispose(ref _branch_filter_sub);
+
       static IEnumerable<CVOrderBookRowVM> _descendents(CVOrderBookRowVM root) {
          foreach (var child in root.child_orders) {
             yield return child;
@@ -310,5 +272,66 @@ namespace mbts.spark {
                yield return grand_child;
          }
       }
+
+      static IOrderBookCellStore _cell_store_from_column(CVOrderBookRowVM row, Columns column) {
+         switch (column) {
+            case Columns.OrderKey: return row._order_key_store;
+            case Columns.ParentKey: return row._parent_order_key_store;
+            case Columns.SecurityKey: return row._security_key_store;
+            case Columns.Security: return row._security_store;
+            case Columns.Exchange: return row._exchange_store;
+            case Columns.OrderType: return row._order_type_store;
+            case Columns.Side: return row._side_store;
+            case Columns.User: return row._user_store;
+            case Columns.Account: return row._account_store;
+            case Columns.TimeInForce: return row._time_in_force_store;
+            case Columns.Time: return row._time_created_store;
+            case Columns.LastChange: return row._last_change_store;
+            case Columns.Status: return row._status_store;
+            case Columns.Price: return row._price_store;
+            case Columns.Size: return row._quantity_store;
+            case Columns.Filled: return row._filled_quantity_store;
+            case Columns.LastPrice: return row._last_price_store;
+            case Columns.AvgFilled: return row._avg_price_store;
+            case Columns.LastMessage: return row._last_msg_store;
+            case Columns.SubType: return row._order_sub_type_store;
+            default: throw new ArgumentException(nameof(column));
+         }
+      }
+
+      // Note: this method assumes that lineage exists (i.e. _parent is not null).
+      void _on_lineage_changed() {
+         _depth_level.refresh();
+         // parent 'branch_filter_source' can be null:
+         // if the parent is itself an orphan - meaning this is the middle of an update -
+         // the final branch-filter-root will be determined after all new orders have been added
+         if (_parent._branch_filter_source != null)
+            join_branch_filter_source(_parent._branch_filter_source);
+         _visible.set(_parent.is_visible && _parent.is_expanded);
+         // refresh the sort by calling regenerate_cell() for each live-sorting-columns corresponding cell-store
+         foreach (Columns column in _book_vm.live_sorting_columns)
+            _cell_store_from_column(this, column).regenerate_cell();
+         // finally, repeat for each child-row
+         foreach (var child_row in _child_rows)
+            child_row._on_lineage_changed();
+      }
+
+      void _update_partial(IEnumerable<IOrderBookCellStore> target_cell_stores) {
+         bool invalidate = false;
+         foreach (var cell_store in target_cell_stores) {
+            if (cell_store.refresh()) {
+               invalidate = true;
+               if (_book_vm.live_sorting_columns.Contains(cell_store.column.key)) {
+                  // refresh the sort by calling regenerate_cell() for each descendent-row
+                  foreach (CVOrderBookRowVM dr in _descendents(this))
+                     cell_store.select_other(dr).regenerate_cell();
+               }
+            }
+         }
+         if (invalidate)
+            invalidated?.Invoke();
+         _show_order_modify_cmd.OnNext(status.value == OrderStatus.Working);
+         refresh_row_passes_filter();
+      }
    }
 }

src/client/spark/view/Spark/Shell/CVOrderBook/CVOrderBookVM.cs

@@ -6,6 +6,7 @@ using mbts.ui;
 using mbts.ui.controls;
 using mbts.ui.shell;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
@@ -16,6 +17,8 @@ using System.Reactive.Subjects;
 using System.Windows.Controls;
 using System.Windows.Data;
 using static bts.shell.OrderBookWindowFactory;
+using static mbts.spark.OrderBookView;
+using static mbts.ui.controls.DIYGrid;
 
 namespace mbts.spark {
    partial class CVOrderBookVM : DisposableViewModelBase, IHandleRowSelection, IOrderBookVM {
@@ -23,29 +26,27 @@ namespace mbts.spark {
       // each row accesses the public 'live_sorting_props' when it, or an ancestor order, is updated,
       // copying the collection locally avoids constantly casting rows_view to ICollectionViewLiveShaping.
       readonly ObservableCollection<string> _live_sorting_props;
+      readonly LiveSortingColumKeys _live_sorting_columns;
       readonly Property<CVOrderBookRowVM> _current_row;
-      readonly Subject<(IReadOnlyList<SecurityImmutable> added, IReadOnlyList<SecurityImmutable> removed)> _order_securities_subject =
-         new Subject<(IReadOnlyList<SecurityImmutable> added, IReadOnlyList<SecurityImmutable> removed)>();
+      readonly Subject<(IEnumerable<SecurityImmutable> added, IEnumerable<SecurityImmutable> removed)> _order_securities_subject =
+         new Subject<(IEnumerable<SecurityImmutable> added, IEnumerable<SecurityImmutable> removed)>();
 
-      IReadOnlyDictionary<uint, OrderRecordImmutable> _orders_cache = new Dictionary<uint, OrderRecordImmutable>();
-      Dictionary<uint, CVOrderBookRowVM> _order_vms_cache = new Dictionary<uint, CVOrderBookRowVM>();
-      ObservableCollection<CVOrderBookRowVM> _order_vms = new ObservableCollection<CVOrderBookRowVM>();
+      Dictionary<uint, CVOrderBookRowVM> _order_rows_cache = new Dictionary<uint, CVOrderBookRowVM>();
+      Dictionary<uint, BranchFilterSource> _branch_filter_roots = new Dictionary<uint, BranchFilterSource>();
+      ObservableCollection<CVOrderBookRowVM> _order_rows = new ObservableCollection<CVOrderBookRowVM>();
       ObservableCollection<CVOrderBookRowVM> _selected_rows = new ObservableCollection<CVOrderBookRowVM>();
       SetMap<uint, uint> _parent_to_children = new SetMap<uint, uint>();
       SetMap<uint, uint> _security_orders = new SetMap<uint, uint>();
 
       public CVOrderBookVM(IBus bus, OrdersModel model, OrderBookStartupData state) {
          columns = new CVOrderBookColumnCollection(bus, model, state, _order_securities_subject);
-         rows_view = CollectionViewSource.GetDefaultView(_order_vms);
+         foreach (ColumnBase col in columns)
+            col.sort_direction_changed += on_column_sort_direction_changed;
+         rows_view = CollectionViewSource.GetDefaultView(_order_rows);
          rows_view.Filter = obj => obj is CVOrderBookRowVM vm && vm.is_visible && vm.passes_filter;
          columns.filter_changed += () => {
-            var root_nodes = new HashSet<CVOrderBookRowVM>();
-            foreach (var vm in _order_vms) {
+            foreach (var vm in _order_rows)
                vm.refresh_row_passes_filter();
-               root_nodes.Add(CVOrderBookRowVM.root_node(vm));
-            }
-            foreach (var vm in root_nodes)
-               vm.refresh_branch_passes_filter();
          };
          var cvls = (ICollectionViewLiveShaping)rows_view;
          _live_sorting_props = cvls.LiveSortingProperties;
@@ -63,98 +64,129 @@ namespace mbts.spark {
             rows_view.SortDescriptions.Add(new SortDescription(nameof(CVOrderBookRowVM.time_created), ListSortDirection.Descending));
             _live_sorting_props.Add(nameof(CVOrderBookRowVM.time_created));
          }
+         _live_sorting_columns = new LiveSortingColumKeys(_live_sorting_props);
 
          SetMap<uint, uint> missing_security_orders = new SetMap<uint, uint>();
          IReadOnlyDictionary<uint, SecurityMD> security_dict = new Dictionary<uint, SecurityMD>();
 
          _dispose = Disposable.Create(
-            bus.subscribe(SparkTags.SecuritiesTag).ObserveOnDispatcher().Subscribe(on_securities),
-            model.on_orders.ObserveOnDispatcher().Subscribe(on_orders),
+            bus.subscribe(SparkTags.SecuritiesTag).OnDispatcher().Subscribe(on_securities),
+            model.on_orders.OnDispatcher().Subscribe(on_orders),
             columns);
 
          void on_orders(TableUpdate<OrderRecordImmutable, uint> table) {
-            // check sum (seems like there is a bug in orders api, see repro steps below)
-            //    1) with an CVOrderBook open, enter a few 500+ lot iceberg order with < 20 show_quantity
-            //    2) wait until the orders are filled, or until fills inexplicably stop coming in
-            //    3) open another CVOrderBook, all the orders in the new book will have 'Status = inactive'
-            //    4) open the log file and scroll to the bottom to find a log-message that came from the code below
-            IEnumerable<OrderRecordImmutable> added, removed;
-            if (_orders_cache.Count != (table.state.Count + table.removed.Count - table.added.Count)) {
-               Logger.error(bts.log.Subsystem.Ui, $"CVOrderBook detected non-incremental changes in orders api, will delete all rows and (re)add everything in api state: " +
-                  $"orderbook count before update({_orders_cache.Count}), update.state count({table.state.Count}), update.added count({table.added.Count}), update.removed count({table.removed.Count}).");
-               _order_vms.Clear();
+            // clear everything (most likely the server restarted)
+            if (table.removed.Count == _order_rows.Count && table.added.Count == 0) {
+               _selected_rows.Clear();
+               _order_rows.DisposeAll();
+               _order_rows.Clear();
+               _order_rows_cache.Clear();
+               _branch_filter_roots.Clear();
                _parent_to_children.clear();
-               added = table.state.Values;
-               removed = Enumerable.Empty<OrderRecordImmutable>();
-            } else {
-               added = table.added;
-               removed = table.removed;
+               _security_orders.clear();
+               missing_security_orders.clear();
+               return;
             }
-            _orders_cache = table.state;
             var changed_keys = new HashSet<uint>();
             var added_securities = new List<SecurityImmutable>(1);
             var removed_securities = new List<SecurityImmutable>(1);
-            foreach (var o in removed) {
+
+            foreach (var o in table.removed) {
                // if state has it, then it wasn't actually removed, just changed
                if (table.state.TryGetValue(o.Key, out OrderRecordImmutable changed_order)) {
                   changed_keys.Add(o.Key);
-                  _order_vms_cache[o.Key].update_order(changed_order);
-               } else if (_order_vms_cache.TryPopValue(o.Key, out CVOrderBookRowVM vm)) {
+                  _order_rows_cache[o.Key].update_order(changed_order);
+               } else if (_order_rows_cache.TryPopValue(o.Key, out CVOrderBookRowVM row)) {
+                  row.Dispose();
+                  _order_rows.Remove(row);
                   if (_security_orders.removes_key(o.Def.SecurityKey, o.Key)) {
-                     if (vm.security.value.HasValue)
-                        removed_securities.Add(vm.security.value.Value);
+                     if (row.security.value.HasValue)
+                        removed_securities.Add(row.security.value.Value);
                   }
-                  _order_vms.Remove(vm);
                   if (o.has_parent()) {
                      _parent_to_children.remove(o.ParentKey, o.Key);
-                     vm.parent_row?.remove_child_order(vm);
+                     if (row.parent != null) {
+                        row.parent.remove_child_order(row);
+                     } else {
+                        _branch_filter_roots.Remove(o.Key);
+                     }
+                  } else {
+                     _branch_filter_roots.Remove(o.Key);
                   }
-                  if (_parent_to_children.try_pop(o.Key, out ISet<uint> children)) {
-                     foreach (var k in children)
-                        _order_vms_cache[k].on_parent_updated();
+                  // the child_rows will most-likely be removed in this update, but we can't be sure,
+                  // until that happens they must serve as tempororay branch-filter-roots
+                  foreach (var child_row in row.child_orders) {
+                     var bfs = new BranchFilterSource();
+                     child_row.remove_parent(bfs);
+                     _branch_filter_roots.Add(child_row.order.Key, bfs);
                   }
                   missing_security_orders.remove(o.Key);
                }
             }
-            var orphans = new List<CVOrderBookRowVM>();
-            foreach (var o in added) {
+            var orphans = new Dictionary<uint, CVOrderBookRowVM>();
+            foreach (var o in table.added) {
                if (changed_keys.Contains(o.Key))
                   continue;
-               var vm = new CVOrderBookRowVM(bus, this, model, o, security_dict.TryGetValue(o.Def.SecurityKey, out SecurityMD smd) ? new SecurityImmutable?(smd.security) : null);
-               if (!vm.security.value.HasValue)
+               SecurityImmutable? security;
+               if (security_dict.TryGetValue(o.Def.SecurityKey, out SecurityMD smd)) {
+                  security = smd.security;
+                  if (_security_orders.adds_key(o.Def.SecurityKey, o.Key))
+                     added_securities.Add(security.Value);
+               } else {
                   missing_security_orders.add(o.Def.SecurityKey, o.Key);
-               if (_security_orders.adds_key(o.Def.SecurityKey, o.Key)) {
-                  if (vm.security.value.HasValue)
-                     added_securities.Add(vm.security.value.Value);
+                  security = null;
+                  _security_orders.add(o.Def.SecurityKey, o.Key);
                }
-               _order_vms_cache.Add(o.Key, vm);
-               if (_parent_to_children.try_lookup(o.Key, out ISet<uint> children))
-                  foreach (var k in children) {
-                     // ** if children arrived in earlier update, this will notify them
-                     // that their parent has arrived, and cause them to be properly sorted **
-                     vm.add_child_order(_order_vms_cache[k]);
-                  }
-               if (o.has_parent()) {
+               CVOrderBookRowVM row = new CVOrderBookRowVM(bus, this, model, o, security);
+               if (!o.has_parent()) {
+                  // if it doesn't have a parent, it must be a root; create a new BranchFilterSource
+                  var bfs = new BranchFilterSource();
+                  _branch_filter_roots.Add(o.Key, bfs);
+                  row.join_branch_filter_source(bfs);
+               } else {
                   _parent_to_children.add(o.ParentKey, o.Key);
-                  if (_order_vms_cache.TryGetValue(o.ParentKey, out CVOrderBookRowVM pvm)) {
-                     pvm.add_child_order(vm);
+                  if (_order_rows_cache.TryGetValue(o.ParentKey, out CVOrderBookRowVM pvm)) {
+                     pvm.add_child_order(row);
                   } else {
-                     // look for orphans' parents again after all new orders have been added to _order_vm_cache
-                     orphans.Add(vm);
+                     // (**) look for orphans' parents again after all new orders have been added to _order_vm_cache
+                     // don't create a temporary BranchFilterSource root just yet. (**)
+                     orphans.Add(o.Key, row);
+                     _order_rows_cache.Add(o.Key, row);
+                     try_add_children(row);
                      continue;
                   }
                }
-               _order_vms.Add(vm);
+               _order_rows_cache.Add(o.Key, row);
+               _order_rows.Add(row);
+               try_add_children(row);
             }
-            // ** add the orphans now, most likely their parent was added after them in the iteration
-            // if not, they will be notified when their parent arrives, and be properly sorted then. **
-            foreach (var vm in orphans) {
-               if (_order_vms_cache.TryGetValue(vm.parent_order_key.value, out CVOrderBookRowVM p))
-                  p.add_child_order(vm);
-               _order_vms.Add(vm);
+            // (**) since all new rows have been added by now, any remaining orphans will be assigned their own branch-filter-roots
+            // (usually, rows are tempororily added to orphans bc their parent is just behind them in the list of added orders) (**)
+            foreach (CVOrderBookRowVM row in orphans.Values) {
+               var bfs = new BranchFilterSource();
+               row.join_branch_filter_source(bfs);
+               _branch_filter_roots.Add(row.order.Key, bfs);
+               _order_rows.Add(row);
             }
             if (added_securities.Count > 0 || removed_securities.Count > 0)
                _order_securities_subject.OnNext((added_securities, removed_securities));
+
+            void try_add_children(CVOrderBookRowVM row) {
+               if (_parent_to_children.try_lookup(row.order.Key, out ISet<uint> children))
+                  foreach (uint child_key in children) {
+                     CVOrderBookRowVM child_vm = _order_rows_cache[child_key];
+                     // (**) if children arrived in an earlier update, this will notify them that their parent has arrived (**)
+                     //    - their tempororary branch-filter-roots will be removed, and they will join that of their parent's
+                     //    - for the live-filter-properties, their corresponding cells will be regenerated and they will be re-inserted beneath their new parent.
+                     row.add_child_order(child_vm);
+                     if (orphans.Remove(child_key))
+                        _order_rows.Add(child_vm);
+                     else {
+                        _order_rows.Remove(child_vm);
+                        _order_rows.Add(child_vm);
+                     }
+                  }
+            }
          }
 
          // I assume we don't need to worry about orders "losing" or "changing" their security
@@ -167,7 +199,7 @@ namespace mbts.spark {
                   missing_security_orders.remove(missing_sec_orders.Key);
                   added_securities.Add(smd.security);
                   foreach (var order_key in missing_sec_orders) {
-                     var vm = _order_vms_cache[order_key];
+                     var vm = _order_rows_cache[order_key];
                      vm.update_security(smd.security);
                   }
                }
@@ -175,30 +207,32 @@ namespace mbts.spark {
             if (added_securities.Count > 0)
                _order_securities_subject.OnNext((added_securities, new List<SecurityImmutable>(0)));
          }
+
+         // need to add sort_member_path to ICollectionView.LiveSortingProperties
+         // since child-orders' sort position must always follow their parent,
+         // if their parent is added after the child, the sort order must be updated.
+         void on_column_sort_direction_changed(ColumnBase column, ListSortDirection? sort_direction) {
+            if (column.SortDirection.HasValue) {
+               if (!_live_sorting_props.Contains(column.sort_member_path))
+                  _live_sorting_props.Add(column.sort_member_path);
+            } else {
+               _live_sorting_props.Remove(column.sort_member_path);
+            }
+         }
       }
 
       public event Action<OrderRecordImmutable?> selected_order_changed;
 
       public CVOrderBookColumnCollection columns { get; }
       public IReadOnlyList<string> live_sorting_props => _live_sorting_props;
+      public ISet<Columns> live_sorting_columns => _live_sorting_columns;
       public ICollectionView rows_view { get; }
       // this is a misnomer, but i want to support both kinds of OrderBookVMs, and OrderBookView currently binds to 'visible_orders,'
       public ICollectionView visible_orders => rows_view;
       public CVOrderBookRowVM current_row { get => _current_row.Value; set => _current_row.Value = value ?? _selected_rows.FirstOrDefault(); }
       public OrderRecordImmutable? current_order => current_row?.order;
       public IEnumerable<OrderRecordImmutable> selected_orders => _selected_rows.Select(r => r.order);
-
-      // need to add sort_member_path to ICollectionView.LiveSortingProperties
-      // since child-orders' sort position must always follow their parent,
-      // if their parent is added after the child, the sort order must be updated.
-      public void on_sorting(DIYGridSortingEventArgs e) {
-         if (e.Column.SortDirection.HasValue) {
-            if (!_live_sorting_props.Contains(e.Column.sort_member_path))
-               _live_sorting_props.Add(e.Column.sort_member_path);
-         } else {
-            _live_sorting_props.Remove(e.Column.sort_member_path);
-         }
-      }
+      void IOrderBookVM.on_sorting(DIYGridSortingEventArgs e) { }
 
       public void row_selection_changed(SelectionChangedEventArgs e) {
          RowSelectionHelper.apply_changes(_selected_rows, e);
@@ -207,5 +241,89 @@ namespace mbts.spark {
 
       public List<SortingCriteria> get_sorting_states() => rows_view.GetSortingCriteria();
       public FilterStates get_filter_states() => columns.get_filter_states();
+
+      internal void remove_branch_filter_root(uint key) =>
+         _branch_filter_roots.Remove(key);
+
+      internal class BranchFilterSource : IObservable<bool> {
+         readonly HashSet<uint> _orders_pass_filter = new HashSet<uint>();
+         event Action<bool> _passes_filter_changed;
+
+         public void set_row_passes_filter(uint key, bool value) {
+            if (value) {
+               if (_orders_pass_filter.Add(key) && _orders_pass_filter.Count == 1)
+                  _passes_filter_changed?.Invoke(value);
+            } else if (_orders_pass_filter.Remove(key) && _orders_pass_filter.Count == 0) {
+               _passes_filter_changed?.Invoke(value);
+            }
+         }
+
+         public IDisposable Subscribe(IObserver<bool> observer) {
+            _passes_filter_changed += observer.OnNext;
+            observer.OnNext(_orders_pass_filter.Count > 0);
+            return Disposable.Create(() => _passes_filter_changed -= observer.OnNext);
+         }
+      }
+
+      class LiveSortingColumKeys : HashSet<Columns> {
+         public LiveSortingColumKeys(ObservableCollection<string> live_sorting_props) {
+            _add_items(live_sorting_props);
+            live_sorting_props.CollectionChanged += (s, e) => {
+               switch (e.Action) {
+                  case NotifyCollectionChangedAction.Add: _add_items(e.NewItems); break;
+                  case NotifyCollectionChangedAction.Remove: _remove_items(e.OldItems); break;
+                  case NotifyCollectionChangedAction.Replace:
+                     _remove_items(e.OldItems);
+                     _add_items(e.NewItems);
+                     break;
+                  case NotifyCollectionChangedAction.Reset:
+                     Clear();
+                     _add_items(live_sorting_props);
+                     break;
+               }
+            };
+         }
+
+         public static bool try_parse(string prop_name, out Columns result) {
+            switch (prop_name) {
+               case nameof(CVOrderBookRowVM.security): result = Columns.Security; break;
+               case nameof(CVOrderBookRowVM.time_created): result = Columns.Time; break;
+               case nameof(CVOrderBookRowVM.last_change): result = Columns.LastChange; break;
+               case nameof(CVOrderBookRowVM.user): result = Columns.User; break;
+               case nameof(CVOrderBookRowVM.account): result = Columns.Account; break;
+               case nameof(CVOrderBookRowVM.exchange): result = Columns.Exchange; break;
+               case nameof(CVOrderBookRowVM.time_in_force): result = Columns.TimeInForce; break;
+               case nameof(CVOrderBookRowVM.order_type): result = Columns.OrderType; break;
+               case nameof(CVOrderBookRowVM.order_sub_type): result = Columns.SubType; break;
+               case nameof(CVOrderBookRowVM.side): result = Columns.Side; break;
+               case nameof(CVOrderBookRowVM.quantity): result = Columns.Size; break;
+               case nameof(CVOrderBookRowVM.filled_quantity): result = Columns.Filled; break;
+               case nameof(CVOrderBookRowVM.price): result = Columns.Price; break;
+               case nameof(CVOrderBookRowVM.avg_price): result = Columns.AvgFilled; break;
+               case nameof(CVOrderBookRowVM.last_price): result = Columns.LastPrice; break;
+               case nameof(CVOrderBookRowVM.status): result = Columns.Status; break;
+               case nameof(CVOrderBookRowVM.last_msg): result = Columns.LastMessage; break;
+               case nameof(CVOrderBookRowVM.security_key): result = Columns.SecurityKey; break;
+               case nameof(CVOrderBookRowVM.order_key): result = Columns.OrderKey; break;
+               case nameof(CVOrderBookRowVM.parent_order_key): result = Columns.ParentKey; break;
+               default: result = default; return false;
+            }
+            return true;
+         }
+
+         void _add_items(IList prop_names) {
+            foreach (string pn in prop_names) {
+               if (try_parse(pn, out Columns c))
+                  Add(c);
+            }
+         }
+
+         void _remove_items(IList prop_names) {
+            foreach (string pn in prop_names) {
+               if (try_parse(pn, out Columns c))
+                  Remove(c);
+            }
+         }
+      }
    }
 }

src/client/spark/view/Spark/Shell/OrderBook/OrderBookVM.cs

@@ -120,7 +120,7 @@ namespace mbts.spark {
                }
                return orders_and_securities;
             })
-            .ObserveOnDispatcher()
+            .OnDispatcher()
             .Subscribe(order_security_pairs => {
                using (_visible_orders.defer_refresh())
                {