Merge branch 'master' of bitbucket.org:bluetradesys/spark into prod

Ladder recenter no kb

doc/user/content/release_notes/_index.md

@@ -6,9 +6,14 @@ insert_anchor_links = "right"
 +++
 ## 2.14.0
 ### User Visible Changes  
+  - All ladders can now be recentered by (shift or alt) + double clicking over the Price column in a ladder
+  - Added a Max Order Quantity setting to the Safety Checks tab on the Ladder settings. This setting allows for a user-defined maximum order quantity.
+  - Added a Price Display Format setting to the Market Price and Size Display tab on the Ladder settings. This setting allows for price levels in the ladder to be displayed without a decimal separator.
+  - Synthetic instrument creation with 3 legs no longer defaults to butterfly quantites
 ### Bug Fixes
   - Fixed an issue where market transition were not observed by IAlgoOrder
   - Fixed a bug in error reporting
+  - Fixed a bug in the PnL window where specifying a certain grouping order would lead to a UI failure
 
 ## 2.13.0
 ### User Visible Changes  

src/client/spark/Modules/Trading/Ladder/VM/LadderVM.cs

@@ -467,6 +467,10 @@ namespace mbts.spark {
          settings_invalidated?.Invoke();
       }
 
+      public void recenter_all_ladders() {
+         _bus?.post(SparkTags.RequestRecenterLadder, null);
+      }
+
       public Task send_order_async((double price, Side? side, MouseButton button) args) {
          if (order_properties_vm != null && args.button != MouseButton.Middle) {
             var size_from_alternate = args.button == MouseButton.Right;

src/client/spark/Modules/Trading/Ladder/View/LadderGridHost.cs

@@ -490,8 +490,14 @@ namespace mbts.spark {
 
       protected override void OnMouseDoubleClick(MouseButtonEventArgs e) {
          var column = _column_for_point(e.GetPosition(this));
-         if (column.column_type == ColumnType.Price)
-            _scroll_to_center();
+         if (column.column_type == ColumnType.Price) {
+            if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift) ||
+               Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt)) {
+               _vm?.recenter_all_ladders();
+            } else {
+               _scroll_to_center();
+            }
+         }
       }
 
       #region Row Utility Methods

src/client/spark/Modules/Trading/PNL/Settings/VM/PNLSettingsVM.cs

@@ -1,220 +1,223 @@
-using bts.collections;
-using bts.utils;
-using mbts;
-using mbts.collections;
-using mbts.expression;
-using mbts.spark;
-using mbts.ui;
-using mbts.ui.settings;
-using mbts.ui.shell;
-using mbts.ui.spark;
-using mbts.ui.utility;
-using mbts.utils;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Collections.Specialized;
-using System.Dynamic;
-using System.Linq;
-using ColumnKeys = bts.shell.pnl.PNLView.Columns;
-
-namespace bts.shell.pnl {
-   class PNLSettingsVM : DisposableViewModelBase, IWindowSettingsVM<PNLSettings>, IValueFactory<PNLSettings>, IObservable<PNLSettings>, ITemplateSelectorKey {
-      readonly IReadOnlyDictionary<ColumnKeys, AnchorItemVM> _anchor_cache;
-      readonly DeferrableActionWrapper _sync_anchors;
-
-      PNLCalculationType _calculation_type;
-      PNLHeaderRowDisplay _header_row_display;
-      PNLSettings _last_loaded;
-
-      public PNLSettingsVM(PNLSettings settings) {
-         // init anchor cache, deferrable resync
-         _anchor_cache = PNLSettings.anchorable_columns.ToDictionary(k => k, k => new AnchorItemVM(this, k));
-         _sync_anchors = new DeferrableActionWrapper(() => {
-            for (int i = 0; i < anchor_items.Count; i++) {
-               anchor_items[i].anchor_index = i + 1;
-               anchor_items[i].refresh();
-            }
-         });
-         core_settings_vm = new SimpleGridSettingsVM(column_factory: col_settings => {
-            var col_vm = new PNLColumnVM(core_settings_vm, EnumHelper.parse<ColumnKeys>(col_settings.id));
-            col_vm.load_from(col_settings);
-            return col_vm;
-         });
-         core_settings_vm.selection_highlight.bind_opacity_to_alpha = true;
-         _dispose = Disposable.Create(
-            anchor_items.Subscribe((s, e) => _sync_anchors.execute()));
-         load(settings);
-      }
-
-      public IEnumerable<AnchorItemVM> anchor_item_headers => _anchor_cache.Values;
-      public ObservableCollection<AnchorItemVM> anchor_items { get; } = new ObservableCollection<AnchorItemVM>();
-      public SimpleGridSettingsVM core_settings_vm { get; }
-      public PNLGroupRowAppearanceVM group_row_defaults { get; } = new PNLGroupRowAppearanceVM();
-      public PNLCellAppearanceVM header_row_defaults { get; } = new PNLCellAppearanceVM();
-      public PNLCalculationType calculation_type { get => _calculation_type; set => Set(ref _calculation_type, value); }
-      public IEnumerable<PNLCalculationType> calculation_types => EnumHelper.get_values_except(PNLCalculationType.None, PNLCalculationType.Same, PNLCalculationType.Opposite);
-      public PNLHeaderRowDisplay header_row_display { get => _header_row_display; set => Set(ref _header_row_display, value); }
-      public IEnumerable<PNLHeaderRowDisplay> header_row_display_options => PNLSettings.header_row_display_options;
-
-      string ITemplateSelectorKey.key => GridSettingsTemplateKeys.PNL;
-
-      public PNLSettings get_result() {
-         var s = _last_loaded == null ? new PNLSettings() : SparkUtils.clone_proto(_last_loaded);
-         s.calculation_type = _calculation_type;
-         s.grid = core_settings_vm.create();
-         // move anchor cols to the left, order wrt grouping hierarchy
-         var new_cols = new Lazy<List<GridColumnSettings>>(() => s.grid.columns.ToList());
-         for (int i = 0; i < s.grid.columns.Count; i++) {
-            var key = s.grid.columns[i].strong_id<ColumnKeys>();
-            if (_anchor_cache.TryGetValue(key, out var a) && a.anchor_index.HasValue) {
-               // anchor index is 1 based, subtract 1 to get 0 based
-               int anchor_index = a.anchor_index.Value - 1;
-               if (anchor_index != i && anchor_index >= 0 && anchor_index < s.grid.columns.Count) {
-                  new_cols.Value.RemoveAt(i);
-                  new_cols.Value.Insert(anchor_index, s.grid.columns[i]);
-               }
+using bts.collections;
+using bts.utils;
+using mbts;
+using mbts.collections;
+using mbts.expression;
+using mbts.spark;
+using mbts.ui;
+using mbts.ui.settings;
+using mbts.ui.shell;
+using mbts.ui.spark;
+using mbts.ui.utility;
+using mbts.utils;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Dynamic;
+using System.Linq;
+using ColumnKeys = bts.shell.pnl.PNLView.Columns;
+
+namespace bts.shell.pnl {
+   class PNLSettingsVM : DisposableViewModelBase, IWindowSettingsVM<PNLSettings>, IValueFactory<PNLSettings>, IObservable<PNLSettings>, ITemplateSelectorKey {
+      readonly IReadOnlyDictionary<ColumnKeys, AnchorItemVM> _anchor_cache;
+      readonly DeferrableActionWrapper _sync_anchors;
+
+      PNLCalculationType _calculation_type;
+      PNLHeaderRowDisplay _header_row_display;
+      PNLSettings _last_loaded;
+
+      public PNLSettingsVM(PNLSettings settings) {
+         // init anchor cache, deferrable resync
+         _anchor_cache = PNLSettings.anchorable_columns.ToDictionary(k => k, k => new AnchorItemVM(this, k));
+         _sync_anchors = new DeferrableActionWrapper(() => {
+            for (int i = 0; i < anchor_items.Count; i++) {
+               anchor_items[i].anchor_index = i + 1;
+               anchor_items[i].refresh();
             }
-         }
-         // rule-based animations
-         var trigger_anims = core_settings_vm.columns
-            .OfType<PNLColumnVM>()
-            .SelectMany(c => c.get_triggers())
-            .GroupBy(tup => tup.expression)
-            .Where(g => CoreExpressionEvaluator<PNLRowData>.validate(g.Key))
-            .Select(g => (
-               expression: g.Key,
-               animations: g.ToArray()))
-            .ToList();
-
-         var normalized_anims = trigger_anims
-            .Where(tup => CoreExpressionEvaluator<PNLNormalizedData>.validate(tup.expression))
-            .ToList();
-
-         s = s.with(anchors: anchor_items.Select(vm => vm.key),
-            grid: new_cols.IsValueCreated ? s.grid.with(columns: new_cols.Value) : null,
-            group_columns: core_settings_vm.columns.OfType<PNLColumnVM>().Select(c => {
-               var col_settings = c.create();
-               col_settings = c.group_column_vm.apply_to(col_settings);
-               return col_settings;
-            }),
-            header_columns: core_settings_vm.columns.OfType<PNLColumnVM>().Select(c => {
-               var col_settings = c.create();
-               col_settings = c.header_column_vm.apply_to(col_settings);
-               return col_settings;
-            }),
-            animations: trigger_anims.Select(
-               ta => new PNLAnimationTriggerData {
-                  expression = ta.expression,
-                  animations = Array.ConvertAll(ta.animations, t => t.row)
-               }),
-            group_header_animations: normalized_anims
-            .Select(
-               ta => new PNLAnimationTriggerData {
-                  expression = ta.expression,
-                  animations = Array.ConvertAll(ta.animations, t => t.group)
-               }),
-            header_row_animations: normalized_anims.Select(
-               ta => new PNLAnimationTriggerData {
-                  expression = ta.expression,
-                  animations = Array.ConvertAll(ta.animations, t => t.header)
-               }));
-         s.header_row_display = header_row_display;
-         s.header_cell_appearance = PNLCellAppearanceProto.from_appearance(header_row_defaults.to_appearance());
-         // group
-         var (group_cell_appearance, group_row_background_colors) = group_row_defaults.create();
-         s.group_cell_appearance = PNLCellAppearanceProto.from_appearance(group_cell_appearance);
-         s.group_background_colors.SetItems(group_row_background_colors.Select(c => c.rgb_color()));
-         //
-         return s;
-      }
-
-      public void load(PNLSettings value) {
-         _last_loaded = value;
-         header_row_defaults.load(value.header_cell_appearance.to_appearance());
-         group_row_defaults.load_from((value.group_cell_appearance.to_appearance(), value.group_background_colors.WrapSelectorRO(c => c.argb_color())));
-         var column_map = _map_column_data(value.grid.columns, value.animations);
-         var group_column_map = _map_column_data(value.group_columns, value.group_header_animations);
-         var header_column_map = _map_column_data(value.header_columns, value.header_row_animations);
-
-         core_settings_vm.load_from(value.grid);
-
-         for (int i = 0; i < core_settings_vm.columns.Count; i++) {
-            var col_vm = core_settings_vm.columns[i] as PNLColumnVM ?? throw new InvalidOperationException($"In {nameof(PNLSettingsVM)}, all columns should be of type {typeof(PNLColumnVM)}.");
-            var key = EnumHelper.parse<ColumnKeys>(col_vm.id);
-            var (col_settings, trigger_animations) = column_map[key];
-            var group_data = group_column_map.GetNullable(key);
-            var header_data = header_column_map.GetNullable(key);
-            col_vm.load_from(col_settings, trigger_animations, group_data?.settings, group_data?.triggers, header_data?.triggers, header_data?.settings);
-         }
-         using (_sync_anchors.defer_execution())
-            anchor_items.WrapSelector(a => a.key, k => _anchor_cache[k]).sync_with(value.anchors.Intersect(PNLSettings.anchorable_columns));
-         header_row_display = value.header_row_display;
-         calculation_type = value.calculation_type;
-       }
-
-      PNLSettings IValueFactory<PNLSettings>.create() => get_result();
-      void IValueFactory<PNLSettings>.load_from(PNLSettings value) => load(value);
-      IDisposable IObservable<PNLSettings>.Subscribe(IObserver<PNLSettings> observer) => throw new NotImplementedException();
-
-      static Dictionary<ColumnKeys, (GridColumnSettings settings, Dictionary<string, PNLAnimation> triggers)> _map_column_data(IEnumerable<GridColumnSettings> columns, IEnumerable<PNLAnimationTriggerData> triggers) {
-         var map = columns.ToDictionary(
-            c => c.strong_id<ColumnKeys>(),
-            c => (settings: c, triggers: new Dictionary<string, PNLAnimation>()));
-         foreach (var trig in triggers) {
-            foreach (var anim in trig.animations) {
-               if (map.TryGetValue(anim.column, out var col_data))
-                     col_data.triggers[trig.expression] = anim;
-            }
-         }
-         return map;
-      }
-
-      void _append_or_remove_anchor(ColumnKeys key, bool include) {
-         if (!_anchor_cache.TryGetValue(key, out var vm))
-            throw new KeyNotFoundException($"Column key '{key}' is not anchorable (expected one of: {string.Join(", ", PNLSettings.anchorable_columns)}).");
-         if (vm.include == include)
-            return;
-         if (include) {
-            if (anchor_items.Any(a => a.key == key))
-               throw new InvalidOperationException($"{nameof(anchor_items)} already contains an element with key '{key}.'");
-            anchor_items.Add(vm);
-            vm.anchor_index = anchor_items.Count;
-         } else {
-            if (!anchor_items.Remove(vm))
-               throw new InvalidOperationException($"{nameof(anchor_items)} does not contain an element with key '{key}.'");
-            vm.anchor_index = null;
-         }
-         _sync_anchors.execute();
-      }
-
-      public class AnchorItemVM : ViewModelBase, IEquatable<AnchorItemVM> {
-         readonly PNLSettingsVM _owner;
-         int? _anchor_index;
-
-         public AnchorItemVM(PNLSettingsVM owner, ColumnKeys key) {
-            _owner = owner;
-            this.key = key;
-         }
-
-         public ColumnKeys key { get; }
-         public bool include { get => anchor_index.HasValue; set => _owner._append_or_remove_anchor(key, value); }
-         public int? anchor_index { get => _anchor_index; set => Set(ref _anchor_index, value); }
-
-         public void refresh() =>
-            RaisePropertyChanged(nameof(include), nameof(anchor_index));
-
-         public bool Equals(AnchorItemVM other) =>
-            other != null && key == other.key;
-
-         public override bool Equals(object obj) =>
-            Equals(obj as AnchorItemVM);
-
-         public override int GetHashCode() =>
-            key.GetHashCode();
-
-         public override string ToString() =>
-            EnumHelper.get_display_name(key);
-      }
-   }
+         });
+         core_settings_vm = new SimpleGridSettingsVM(column_factory: col_settings => {
+            var col_vm = new PNLColumnVM(core_settings_vm, EnumHelper.parse<ColumnKeys>(col_settings.id));
+            col_vm.load_from(col_settings);
+            return col_vm;
+         });
+         core_settings_vm.selection_highlight.bind_opacity_to_alpha = true;
+         _dispose = Disposable.Create(
+            anchor_items.Subscribe((s, e) => _sync_anchors.execute()));
+         load(settings);
+      }
+
+      public IEnumerable<AnchorItemVM> anchor_item_headers => _anchor_cache.Values;
+      public ObservableCollection<AnchorItemVM> anchor_items { get; } = new ObservableCollection<AnchorItemVM>();
+      public SimpleGridSettingsVM core_settings_vm { get; }
+      public PNLGroupRowAppearanceVM group_row_defaults { get; } = new PNLGroupRowAppearanceVM();
+      public PNLCellAppearanceVM header_row_defaults { get; } = new PNLCellAppearanceVM();
+      public PNLCalculationType calculation_type { get => _calculation_type; set => Set(ref _calculation_type, value); }
+      public IEnumerable<PNLCalculationType> calculation_types => EnumHelper.get_values_except(PNLCalculationType.None, PNLCalculationType.Same, PNLCalculationType.Opposite);
+      public PNLHeaderRowDisplay header_row_display { get => _header_row_display; set => Set(ref _header_row_display, value); }
+      public IEnumerable<PNLHeaderRowDisplay> header_row_display_options => PNLSettings.header_row_display_options;
+
+      string ITemplateSelectorKey.key => GridSettingsTemplateKeys.PNL;
+
+      public PNLSettings get_result() {
+         var s = _last_loaded == null ? new PNLSettings() : SparkUtils.clone_proto(_last_loaded);
+         s.calculation_type = _calculation_type;
+         s.grid = core_settings_vm.create();
+         // move anchor cols to the left, order wrt grouping hierarchy
+         List<GridColumnSettings> new_cols = null;
+         IEnumerable<GridColumnSettings> cols = s.grid.columns;
+         var sorted_anchors = anchor_items.OrderBy(a => a.anchor_index).ToList();
+         for (int i = 0; i < sorted_anchors.Count; i++) {
+            if (GridSettingsHelper.try_find_column(cols, sorted_anchors[i].key, out var match, out int pos) && pos != i) {
+               if (new_cols == null) {
+                  new_cols = s.grid.columns.ToList();
+                  // set cols to new_cols so subsequent position lookups
+                  // take previous column order manipulations into account.
+                  cols = new_cols;
+               }
+               new_cols.RemoveAt(pos);
+               new_cols.Insert(i, match);
+            }
+         }
+         // rule-based animations
+         var trigger_anims = core_settings_vm.columns
+            .OfType<PNLColumnVM>()
+            .SelectMany(c => c.get_triggers())
+            .GroupBy(tup => tup.expression)
+            .Where(g => CoreExpressionEvaluator<PNLRowData>.validate(g.Key))
+            .Select(g => (
+               expression: g.Key,
+               animations: g.ToArray()))
+            .ToList();
+
+         var normalized_anims = trigger_anims
+            .Where(tup => CoreExpressionEvaluator<PNLNormalizedData>.validate(tup.expression))
+            .ToList();
+
+         s = s.with(anchors: anchor_items.Select(vm => vm.key),
+            grid: new_cols == null ? null : s.grid.with(columns: new_cols),
+            group_columns: core_settings_vm.columns.OfType<PNLColumnVM>().Select(c => {
+               var col_settings = c.create();
+               col_settings = c.group_column_vm.apply_to(col_settings);
+               return col_settings;
+            }),
+            header_columns: core_settings_vm.columns.OfType<PNLColumnVM>().Select(c => {
+               var col_settings = c.create();
+               col_settings = c.header_column_vm.apply_to(col_settings);
+               return col_settings;
+            }),
+            animations: trigger_anims.Select(
+               ta => new PNLAnimationTriggerData {
+                  expression = ta.expression,
+                  animations = Array.ConvertAll(ta.animations, t => t.row)
+               }),
+            group_header_animations: normalized_anims
+            .Select(
+               ta => new PNLAnimationTriggerData {
+                  expression = ta.expression,
+                  animations = Array.ConvertAll(ta.animations, t => t.group)
+               }),
+            header_row_animations: normalized_anims.Select(
+               ta => new PNLAnimationTriggerData {
+                  expression = ta.expression,
+                  animations = Array.ConvertAll(ta.animations, t => t.header)
+               }));
+         s.header_row_display = header_row_display;
+         s.header_cell_appearance = PNLCellAppearanceProto.from_appearance(header_row_defaults.to_appearance());
+         // group
+         var (group_cell_appearance, group_row_background_colors) = group_row_defaults.create();
+         s.group_cell_appearance = PNLCellAppearanceProto.from_appearance(group_cell_appearance);
+         s.group_background_colors.SetItems(group_row_background_colors.Select(c => c.rgb_color()));
+         //
+         return s;
+      }
+
+      public void load(PNLSettings value) {
+         _last_loaded = value;
+         header_row_defaults.load(value.header_cell_appearance.to_appearance());
+         group_row_defaults.load_from((value.group_cell_appearance.to_appearance(), value.group_background_colors.WrapSelectorRO(c => c.argb_color())));
+         var column_map = _map_column_data(value.grid.columns, value.animations);
+         var group_column_map = _map_column_data(value.group_columns, value.group_header_animations);
+         var header_column_map = _map_column_data(value.header_columns, value.header_row_animations);
+
+         core_settings_vm.load_from(value.grid);
+
+         for (int i = 0; i < core_settings_vm.columns.Count; i++) {
+            var col_vm = core_settings_vm.columns[i] as PNLColumnVM ?? throw new InvalidOperationException($"In {nameof(PNLSettingsVM)}, all columns should be of type {typeof(PNLColumnVM)}.");
+            var key = EnumHelper.parse<ColumnKeys>(col_vm.id);
+            var (col_settings, trigger_animations) = column_map[key];
+            var group_data = group_column_map.GetNullable(key);
+            var header_data = header_column_map.GetNullable(key);
+            col_vm.load_from(col_settings, trigger_animations, group_data?.settings, group_data?.triggers, header_data?.triggers, header_data?.settings);
+         }
+         using (_sync_anchors.defer_execution())
+            anchor_items.WrapSelector(a => a.key, k => _anchor_cache[k]).sync_with(value.anchors.Intersect(PNLSettings.anchorable_columns));
+         header_row_display = value.header_row_display;
+         calculation_type = value.calculation_type;
+       }
+
+      PNLSettings IValueFactory<PNLSettings>.create() => get_result();
+      void IValueFactory<PNLSettings>.load_from(PNLSettings value) => load(value);
+      IDisposable IObservable<PNLSettings>.Subscribe(IObserver<PNLSettings> observer) => throw new NotImplementedException();
+
+      static Dictionary<ColumnKeys, (GridColumnSettings settings, Dictionary<string, PNLAnimation> triggers)> _map_column_data(IEnumerable<GridColumnSettings> columns, IEnumerable<PNLAnimationTriggerData> triggers) {
+         var map = columns.ToDictionary(
+            c => c.strong_id<ColumnKeys>(),
+            c => (settings: c, triggers: new Dictionary<string, PNLAnimation>()));
+         foreach (var trig in triggers) {
+            foreach (var anim in trig.animations) {
+               if (map.TryGetValue(anim.column, out var col_data))
+                     col_data.triggers[trig.expression] = anim;
+            }
+         }
+         return map;
+      }
+
+      void _append_or_remove_anchor(ColumnKeys key, bool include) {
+         if (!_anchor_cache.TryGetValue(key, out var vm))
+            throw new KeyNotFoundException($"Column key '{key}' is not anchorable (expected one of: {string.Join(", ", PNLSettings.anchorable_columns)}).");
+         if (vm.include == include)
+            return;
+         if (include) {
+            if (anchor_items.Any(a => a.key == key))
+               throw new InvalidOperationException($"{nameof(anchor_items)} already contains an element with key '{key}.'");
+            anchor_items.Add(vm);
+            vm.anchor_index = anchor_items.Count;
+         } else {
+            if (!anchor_items.Remove(vm))
+               throw new InvalidOperationException($"{nameof(anchor_items)} does not contain an element with key '{key}.'");
+            vm.anchor_index = null;
+         }
+         _sync_anchors.execute();
+      }
+
+      public class AnchorItemVM : ViewModelBase, IEquatable<AnchorItemVM> {
+         readonly PNLSettingsVM _owner;
+         int? _anchor_index;
+
+         public AnchorItemVM(PNLSettingsVM owner, ColumnKeys key) {
+            _owner = owner;
+            this.key = key;
+         }
+
+         public ColumnKeys key { get; }
+         public bool include { get => anchor_index.HasValue; set => _owner._append_or_remove_anchor(key, value); }
+         public int? anchor_index { get => _anchor_index; set => Set(ref _anchor_index, value); }
+
+         public void refresh() =>
+            RaisePropertyChanged(nameof(include), nameof(anchor_index));
+
+         public bool Equals(AnchorItemVM other) =>
+            other != null && key == other.key;
+
+         public override bool Equals(object obj) =>
+            Equals(obj as AnchorItemVM);
+
+         public override int GetHashCode() =>
+            key.GetHashCode();
+
+         public override string ToString() =>
+            EnumHelper.get_display_name(key);
+      }
+   }
 }

src/client/spark/Modules/Trading/PNL/VM/PNLRowComparer.cs

@@ -90,12 +90,11 @@ namespace bts.shell.pnl {
       }
 
       int? _try_compare_groups(CollectionViewGroup x, CollectionViewGroup y) {
-         if (x == null || y == null)
-            return null;
-         var xcell = (IPNLCellData)x.Name;
-         var ycell = (IPNLCellData)y.Name;
-         var comp = _get_column_comparer(xcell.column);
-         return comp.value_comparer.Compare(xcell.value, ycell.value);
+         if (x?.Name is IPNLCellData xcell && y?.Name is IPNLCellData ycell) {
+            var comp = _get_column_comparer(xcell.column);
+            return comp.value_comparer.Compare(xcell.value, ycell.value);
+         }
+         return null;
       }
    }
-}
+}

src/client/spark/Modules/Trading/PNL/View/PNLView.xaml

@@ -698,8 +698,8 @@
               c:DataGridFilterProperties.FilterActive="{Binding DataContext.security_filter.active, Source={u:DirectReference _grid}}"
               c:DataGridFilterProperties.FilterOpen="{Binding DataContext.security_filter.open, Source={u:DirectReference _grid}}"
               key="Security"
-              sort_member_path="security_cell.cell_data"
-              data_member_path="security"
+              data_member_path="security_cell.cell_data"
+              sort_member_path="security"
               HeaderTemplate="{StaticResource AnchorableColumnHeaderTemplate}"
             />
             <!--Security Key-->

src/lib/orderman/actors/ICEExecutionGateway.cpp

@@ -195,6 +195,8 @@ void ICEExecutionGateway::on_trader_login_timeout_expired()
             const auto& ice = u.user_data().exchange_user_data().ice_data();
             if(auth_traders.find(ice.authorized_trader()) == auth_traders.end())
             {
+               if(ice.authorized_trader() == "")
+                  continue;
                if(me->nusers == -1)
                   me->nusers = 0;
                me->nusers++;

src/sdk/Dockerfile

@@ -12,19 +12,22 @@ env SDK_ROOT=/sdk \
     SDK_VERSION=$SDK_VERSION \
     SDK_BUILD_DATE=$SDK_BUILD_DATE
 
-# copy sdk
-COPY include/ /sdk/include/
-COPY lib/ /sparkbin/
-COPY externals /sdk/externals/
-COPY spark.conf /sparkdata/conf/
-COPY futures.coconut /sparkdata/data/replay/futures.coconut
-
 # add user bts
 RUN groupadd --gid 1000 $USERNAME && \
     useradd -s /bin/bash --uid 1000 --gid 1000 -m $USERNAME && \
+    mkdir -p /sparkbin/plugins && \
+    mkdir /sparkdata && \
     ln -s /sparkbin/ sdk/lib && \
     echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME && \
     chmod 0440 /etc/sudoers.d/$USERNAME && \
     chown -R bts.bts /sparkbin/plugins && \
     chown -R bts.bts /sparkdata 
 
+# copy sdk
+COPY include/ /sdk/include/
+COPY lib/ /sparkbin/
+COPY externals /sdk/externals/
+COPY spark.conf /sparkdata/conf/
+COPY --chown=$USERNAME futures.coconut /sparkdata/data/replay/futures.coconut
+
+

src/server/sparkd/md/platforms/ice_onixs/ICEListener.h

@@ -212,30 +212,32 @@ void ICEListener::on_uds_future_spread(const Definition& def, bool& is_intereste
    fsec.alt_symbol(def.strategySymbol);      
    
    const auto& legs = def.legs;
-   fsec.set_leg_count(legs.size());
-   for(size_t x = 0; x < fsec.leg_count(); ++x) 
-   {
-      const auto& leg = legs[x];
-      if(leg.ratioPriceNumerator && leg.ratioPriceDenominator)
+   if (legs.size() > 0) {
+      fsec.set_leg_count(legs.size());
+      for(size_t x = 0; x < fsec.leg_count(); ++x) 
       {
-         auto num = *leg.ratioPriceNumerator;
-         auto denom = *leg.ratioPriceDenominator;
-         fsec.legs[x].leg_price = num / (double) denom;
+         const auto& leg = legs[x];
+         if(leg.ratioPriceNumerator && leg.ratioPriceDenominator)
+         {
+            auto num = *leg.ratioPriceNumerator;
+            auto denom = *leg.ratioPriceDenominator;
+            fsec.legs[x].leg_price = num / (double) denom;
+         }
+         if(leg.ratioQtyNumerator && leg.ratioQtyDenominator)
+         {
+            auto num = *leg.ratioQtyNumerator;
+            auto denom = *leg.ratioQtyDenominator;         
+            fsec.legs[x].leg_delta = num / (double) denom;
+         }
+         
+         fsec.legs[x].leg_quantity = leg.ratio;
+         fsec.legs[x].leg_side = leg.side == onixs_ice::Side::Bid ? api::SIDE_BUY : api::SIDE_SELL;
+         fsec.legs[x].exchange_key = ExchangeKey(leg.marketId);
+         fsec.legs[x].key = invalid_security_key;
       }
-      if(leg.ratioQtyNumerator && leg.ratioQtyDenominator)
-      {
-         auto num = *leg.ratioQtyNumerator;
-         auto denom = *leg.ratioQtyDenominator;         
-         fsec.legs[x].leg_delta = num / (double) denom;
-      }
-      
-      fsec.legs[x].leg_quantity = leg.ratio;
-      fsec.legs[x].leg_side = leg.side == onixs_ice::Side::Bid ? api::SIDE_BUY : api::SIDE_SELL;
-      fsec.legs[x].exchange_key = ExchangeKey(leg.marketId);
-      fsec.legs[x].key = invalid_security_key;
+      add_security(fsec);
+      is_interested = true;            
    }
-   add_security(fsec);
-   is_interested = true;            
 }
 
 

testing/manual/settings/Ladder_RecenterAll.txt

@@ -0,0 +1,6 @@
+1. Verify pressing the shift or alt key while double clicking in the Price column in a Ladder Window recenters ALL ladders
+Launch 2 ladders
+Scroll both ladders so they are no longer centered at mid market
+Press the shift + double click while over the Price column
+	You should observe both scrolled ladders are now centered once again
+	The countdown timer is also reset via this spacebar action. This is more informational; I don't expect you to wait to verify that the timer is reset.