SyntheticEditor2 - Payup\less absolute\ratio toggle

This commit is contained in:
John Colvin committed 2017-09-27 16:03:40 -04:00
1 parent 859b4c602a
commit 8a2c0ac31b
8 files changed
+521 -350

No files matched your search

@@ -1,206 +0,0 @@
using bts.api;
using mbts.ui.spark;
using System;
using System.Collections.Generic;
using System.Linq;
namespace mbts.spark
{
internal partial class SyntheticEditorVM2
{
internal interface IParameter<T> : SyntheticEditor2.IParameter {
T get_value(LegSpreaderParamsTuple leg_tup);
void set_value(LegSpreaderParamsTuple leg_tup, T value);
}
internal static class SectionNames {
public const string
LegDef = "Leg",
Quote = "Quote",
PreHedge = "PreHedge",
PostHedge = "PostHedge";
}
internal static class SubsectionNames {
public const string
Mute = "Mute",
InsideMarketDistance = "Mute Inside Mkt Distance",
InsideMarketDistanceWithTravel = "Mute Inside Mkt Distance & Move",
OrderType = "Order Type",
MarketForcedCross = "Price-Based Mkt Forced Cross",
TimeForcedCross = "Time-Based Forced Cross";
}
internal abstract class ParameterBase<T> : IParameter<T> {
protected ParameterBase() { }
public abstract string display_name { get; }
public virtual string[] section_path { get; } = new string[0];
public virtual IReadOnlyCollection<SyntheticEditor2.IParameter> sub_items { get; }
public abstract T get_value(LegSpreaderParamsTuple leg_tup);
public abstract void set_value(LegSpreaderParamsTuple leg_tup, T value);
public virtual bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups) { return false; }
public SyntheticEditor2.ICell create_cell(LegSpreaderParamsTuple leg_tup) { return new ParameterRowCell<T>(this, leg_tup); }
}
internal class SizeRowModel : ParameterBase<double> {
public override double get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg.Side == BuySell.Buy ? leg_tup.leg.Quantity : -leg_tup.leg.Quantity; }
public override void set_value(LegSpreaderParamsTuple leg_tup, double value) {
if (value >= 0) {
leg_tup.leg.Side = BuySell.Buy;
leg_tup.leg.Quantity = value;
} else {
leg_tup.leg.Side = BuySell.Sell;
leg_tup.leg.Quantity = -value;
}
}
public override string display_name { get; } = "Size";
public override string[] section_path { get; } = new[] { SectionNames.LegDef };
}
internal class PriceMultiplierRowModel : ParameterBase<double> {
public override double get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PriceMultiplier; }
public override void set_value(LegSpreaderParamsTuple leg_tup, double value) { leg_tup.leg_params.PriceMultiplier = value; }
public override string display_name { get; } = "Price Mult";
public override string[] section_path { get; } = new[] { SectionNames.LegDef };
}
internal class IsQuoteRowModel : ParameterBase<bool> {
public override bool get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.IsActiveQuoting; }
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) { leg_tup.leg_params.IsActiveQuoting = value; }
public override string display_name { get; } = "Is Active Quote";
public override string[] section_path { get; } = new[] { SectionNames.Quote };
public override bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups) { return !leg_tups.Any(lt => lt.leg_params.IsActiveQuoting); }
}
#region Quote
internal class LeanRatioRowModel : ParameterBase<double> {
public override string display_name { get; } = "Lean Ratio";
public override string[] section_path { get; } = new[] { SectionNames.Quote };
public override double get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.LeanQuantityRatio; }
public override void set_value(LegSpreaderParamsTuple leg_tup, double value) { leg_tup.leg_params.QuoteParams.LeanQuantityRatio = value; }
}
internal class MaxOrderMoveRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Max Order Move";
public override string[] section_path { get; } = new[] { SectionNames.Quote };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteMaxOrderMove.MaxOrderMoveThreshold; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteMaxOrderMove.MaxOrderMoveThreshold = value; }
}
internal class QuoteMuteZoneInsideTicksRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Inside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.Mute };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteMuteZone.InsideTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteMuteZone.InsideTicks = value; }
}
internal class QuoteMuteZoneOutsideTicksRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Outside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.Mute };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteMuteZone.OutsideTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteMuteZone.OutsideTicks = value; }
}
internal class QuoteInsideMarketDistanceTicksRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.InsideMarketDistance };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistance.TicksFromInside; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistance.TicksFromInside = value; }
}
internal class QuoteInsideMarketDistanceWithTravelTicksRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.InsideMarketDistanceWithTravel };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.TicksFromInside; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.TicksFromInside = value; }
}
internal class QuoteInsideMarketDistanceWithTravelLimitRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Min Move";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.InsideMarketDistanceWithTravel };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.Limit; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.Limit = value; }
}
#endregion
#region PreHedge
internal class PayupRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Payup";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.PayupTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.PayupTicks = value; }
}
internal class PaylessRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Payless";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.PaylessTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.PaylessTicks = value; }
}
internal class MaxTicksInsideMarketRowModel : ParameterBase<uint> {
public override string display_name { get; } = "Max Inside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.MaxPriceFromInsideMarket.HedgeTickLimit; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PreHedgeParams.MaxPriceFromInsideMarket.HedgeTickLimit = value; }
}
internal class SendHedgeAsMarketOrderRowModel : ParameterBase<bool> {
public override string display_name { get; } = "Mkt Order Hedge";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.OrderType };
public override bool get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.SendHedgeAsMarketOrder.SendHedgeAsMarketOrder; }
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) { leg_tup.leg_params.PreHedgeParams.SendHedgeAsMarketOrder.SendHedgeAsMarketOrder = value; }
}
#endregion
#region PostHedge
internal class PostHedgePriceBasedCrossTicks : ParameterBase<uint> {
public override string display_name { get; } = "Max Outside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.MarketForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.PriceBasedCross.TicksThreshold; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.PriceBasedCross.TicksThreshold = value; }
}
internal class PostHedgePriceBasedCrossMarketTicks : ParameterBase<uint> {
public override string display_name { get; } = "Opposite Mkt Cross Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.MarketForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.PriceBasedCross.MarketCrossTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.PriceBasedCross.MarketCrossTicks = value; }
}
internal class PostHedgeTimeBasedCrossTicks : ParameterBase<uint> {
public override string display_name { get; } = "Max Outside Time(ms)";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.TimeForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.TimeInMsThreshold; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.TimeInMsThreshold = value; }
}
internal class PostHedgeTimeBasedCrossMarketTicks : ParameterBase<uint> {
public override string display_name { get; } = "Opposite Mkt Cross Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.TimeForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.MarketCrossTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.MarketCrossTicks = value; }
}
#endregion
internal class ParameterRowCell<T> : SyntheticEditor2.ICell {
public ParameterRowCell(IParameter<T> model, LegSpreaderParamsTuple leg_tup) {
_model = model;
_leg_tup = leg_tup;
}
private readonly IParameter<T> _model;
private readonly LegSpreaderParamsTuple _leg_tup;
public T value {
get => _model.get_value(_leg_tup);
set {
_model.set_value(_leg_tup, value);
value_changed?.Invoke();
}
}
public event Action value_changed;
}
}
}
@@ -3,52 +3,55 @@
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:usp="clr-namespace:mbts.ui.spark">
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="/view/Resources/DataGrid.xaml"/>
</ResourceDictionary.MergedDictionaries>
<usp:RowHeaderGroupIndentConverter x:Key="RowHeaderGroupIndentConverter" Indent="18"/>
<usp:RowHeaderGroupIndentConverter x:Key="ReverseRowHeaderGroupIndentConverter" Indent="-18"/>
<usp:DataGridParameterCellTemplateSelector x:Key="ParameterCellTemplateSelector">
<usp:DataGridParameterCellTemplateSelector.BooleanTemplate>
<usp:DataGridParameterCellTemplateConverter x:Key="ParameterCellTemplateConverter">
<usp:DataGridParameterCellTemplateConverter.BooleanTemplate>
<DataTemplate>
<CheckBox HorizontalAlignment="Left" IsChecked="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.BooleanTemplate>
<usp:DataGridParameterCellTemplateSelector.DoubleTemplate>
</usp:DataGridParameterCellTemplateConverter.BooleanTemplate>
<usp:DataGridParameterCellTemplateConverter.DoubleTemplate>
<DataTemplate>
<TextBlock Text="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.DoubleTemplate>
<usp:DataGridParameterCellTemplateSelector.IntTemplate>
</usp:DataGridParameterCellTemplateConverter.DoubleTemplate>
<usp:DataGridParameterCellTemplateConverter.IntTemplate>
<DataTemplate>
<TextBlock Text="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.IntTemplate>
<usp:DataGridParameterCellTemplateSelector.UIntTemplate>
</usp:DataGridParameterCellTemplateConverter.IntTemplate>
<usp:DataGridParameterCellTemplateConverter.UIntTemplate>
<DataTemplate>
<TextBlock Text="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.UIntTemplate>
</usp:DataGridParameterCellTemplateSelector>
<usp:DataGridParameterCellTemplateSelector x:Key="ParameterCellEditingTemplateSelector">
<usp:DataGridParameterCellTemplateSelector.BooleanTemplate>
</usp:DataGridParameterCellTemplateConverter.UIntTemplate>
</usp:DataGridParameterCellTemplateConverter>
<usp:DataGridParameterCellTemplateConverter x:Key="ParameterCellEditingTemplateConverter">
<usp:DataGridParameterCellTemplateConverter.BooleanTemplate>
<DataTemplate>
<CheckBox HorizontalAlignment="Left" IsChecked="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.BooleanTemplate>
<usp:DataGridParameterCellTemplateSelector.DoubleTemplate>
</usp:DataGridParameterCellTemplateConverter.BooleanTemplate>
<usp:DataGridParameterCellTemplateConverter.DoubleTemplate>
<DataTemplate>
<c:TickUpDownDouble Value="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.DoubleTemplate>
<usp:DataGridParameterCellTemplateSelector.IntTemplate>
</usp:DataGridParameterCellTemplateConverter.DoubleTemplate>
<usp:DataGridParameterCellTemplateConverter.IntTemplate>
<DataTemplate>
<c:TickUpDownInt Value="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.IntTemplate>
<usp:DataGridParameterCellTemplateSelector.UIntTemplate>
</usp:DataGridParameterCellTemplateConverter.IntTemplate>
<usp:DataGridParameterCellTemplateConverter.UIntTemplate>
<DataTemplate>
<c:TickUpDownUInt Value="{Binding value}"/>
</DataTemplate>
</usp:DataGridParameterCellTemplateSelector.UIntTemplate>
</usp:DataGridParameterCellTemplateSelector>
</usp:DataGridParameterCellTemplateConverter.UIntTemplate>
</usp:DataGridParameterCellTemplateConverter>
<Style x:Key="ExpanderToggleButton" TargetType="ToggleButton">
<Setter Property="Template">
<Setter.Value>
@@ -137,6 +140,9 @@
<Setter Property="Template" Value="{StaticResource DataGridRowTemplate}"/>
<Setter Property="usp:SyntheticEditor2.RowHasErrors" Value="{Binding has_errors}"/>
</Style>
<Style x:Key="DataGridCellStyle" TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
<Setter Property="usp:SyntheticEditor2.CellDataType" Value="{Binding data_type}"/>
</Style>
<ControlTemplate x:Key="SyntheticEditor2Template" TargetType="usp:SyntheticEditor2">
<Border BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}"
@@ -168,6 +174,7 @@
HeadersVisibility="All"
RowHeaderWidth="200"
RowStyle="{StaticResource DataGridRowStyle}"
CellStyle="{StaticResource DataGridCellStyle}"
ItemsSource="{Binding ParameterRowsView, RelativeSource={RelativeSource TemplatedParent}}">
<DataGrid.Resources>
<Style x:Key="{ComponentResourceKey ResourceId=DataGridSelectAllButtonStyle, TypeInTargetAssembly={x:Type DataGrid}}" TargetType="Button">
@@ -189,8 +196,8 @@
</Border>
</ControlTemplate>
<Style TargetType="usp:SyntheticEditor2">
<Setter Property="ParameterCellTemplateSelector" Value="{StaticResource ParameterCellTemplateSelector}"/>
<Setter Property="ParameterCellEditingTemplateSelector" Value="{StaticResource ParameterCellEditingTemplateSelector}"/>
<Setter Property="ParameterCellTemplateConverter" Value="{StaticResource ParameterCellTemplateConverter}"/>
<Setter Property="ParameterCellEditingTemplateConverter" Value="{StaticResource ParameterCellEditingTemplateConverter}"/>
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="VerticalAlignment" Value="Stretch"/>
<Setter Property="Template" Value="{StaticResource SyntheticEditor2Template}"/>
@@ -1,8 +1,8 @@
using bts.api;
using mbts.ui.controls;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
@@ -15,117 +15,66 @@ namespace mbts.ui.spark
/// <summary>
/// Interaction logic for SyntheticEditor2.xaml
/// </summary>
///
internal partial class SyntheticEditor2 : Control
{
static SyntheticEditor2() {
DefaultStyleKeyProperty.OverrideMetadata(typeof(SyntheticEditor2), new FrameworkPropertyMetadata(typeof(SyntheticEditor2)));
}
public interface IParameter
{
string display_name { get; }
public interface IHaveSectionPath {
string[] section_path { get; }
bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups);
ICell create_cell(LegSpreaderParamsTuple leg_tup);
}
public interface ICell
{
event Action value_changed;
}
#region SyntheticName
public static readonly DependencyProperty SyntheticNameProperty = DependencyProperty.Register("SyntheticName", typeof(string), typeof(SyntheticEditor2),
new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
public string SyntheticName { get => GetValue(SyntheticNameProperty) as string; set => SetValue(SyntheticNameProperty, value); }
#endregion
#region LegTuples
public static readonly DependencyProperty LegTuplesProperty = DependencyProperty.Register("LegTuples", typeof(IReadOnlyCollection<LegSpreaderParamsTuple>), typeof(SyntheticEditor2),
new FrameworkPropertyMetadata(new LegSpreaderParamsTuple[0], FrameworkPropertyMetadataOptions.AffectsMeasure, OnLegTuplesChanged, CoerceLegTuples));
private static void OnLegTuplesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
GenerateParameterRows(d, e);
SyncColumns(d, e);
}
new FrameworkPropertyMetadata(new LegSpreaderParamsTuple[0], FrameworkPropertyMetadataOptions.AffectsMeasure, SyncColumns, CoerceLegTuples));
private static object CoerceLegTuples(DependencyObject d, object baseValue) {
return baseValue is IReadOnlyCollection<LegSpreaderParamsTuple> ? baseValue : new List<LegSpreaderParamsTuple>();
}
public IReadOnlyCollection<LegSpreaderParamsTuple> LegTuples { get => GetValue(LegTuplesProperty) as IReadOnlyCollection<LegSpreaderParamsTuple>; set => SetValue(LegTuplesProperty, value); }
#endregion
#region Parameters
public static readonly DependencyProperty ParametersProperty = DependencyProperty.Register("Parameters", typeof(IReadOnlyCollection<IParameter>), typeof(SyntheticEditor2),
new PropertyMetadata(new IParameter[0], GenerateParameterRows, CoerceParameters));
private static object CoerceParameters(DependencyObject d, object baseValue) { return baseValue is IReadOnlyCollection<IParameter> ? baseValue : new List<IParameter>(); }
public IReadOnlyCollection<IParameter> Parameters { get => GetValue(ParametersProperty) as IReadOnlyCollection<IParameter>; set => SetValue(ParametersProperty, value); }
#endregion
#region ParameterRows
private static readonly DependencyPropertyKey ParameterRowsPropertyKey = DependencyProperty.RegisterReadOnly("ParameterRows", typeof(IList<ParameterRow>), typeof(SyntheticEditor2),
new PropertyMetadata(new List<ParameterRow>(), OnParameterRowsChanged, CoerceParameterRows));
internal static readonly DependencyProperty ParameterRowsProperty = ParameterRowsPropertyKey.DependencyProperty;
public static readonly DependencyProperty ParameterRowsProperty = DependencyProperty.Register("ParameterRows", typeof(IEnumerable<IHaveSectionPath>), typeof(SyntheticEditor2), new PropertyMetadata(Enumerable.Empty<IHaveSectionPath>(), OnParameterRowsChanged));
private static void OnParameterRowsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
var rows = (IList<ParameterRow>)e.NewValue;
var vs = CollectionViewSource.GetDefaultView(rows);
int n_sections = rows.Select(r => r.section_path.Length).Max();
for (int i = 0; i < n_sections; i++) vs.GroupDescriptions.Add(new PropertyGroupDescription($"[{i}]"));
d.SetValue(ParameterRowsViewPropertyKey, vs);
}
private static object CoerceParameterRows(DependencyObject d, object baseValue) {
return baseValue is IList<ParameterRow> ? baseValue : new List<ParameterRow>();
}
internal IList<ParameterRow> ParameterRows { get => GetValue(ParameterRowsProperty) as IList<ParameterRow>; private set => SetValue(ParameterRowsPropertyKey, value); }
internal class ParameterRow : DataGridExRow<Security>
{
public ParameterRow(IParameter model, IReadOnlyCollection<LegSpreaderParamsTuple> legs) {
_has_errors = backing(nameof(has_errors), false);
_cells = new ReadOnlyDictionary<Security, ICell>(legs.ToDictionary(l => l.leg.Security, model.create_cell));
foreach(var c in _cells.Values) {
_has_errors.set(model.has_errors(legs));
c.value_changed += () => _has_errors.set(model.has_errors(legs));
}
display_name = model.display_name;
section_path = model.section_path;
}
private readonly IReadOnlyDictionary<Security, ICell> _cells;
private readonly Property<bool> _has_errors;
public string display_name { get; }
public string[] section_path { get; }
public int section_count => section_path.Length;
public override object get_cell(Security col_key) { return _cells[col_key]; }
public string this[string section_no] => int.TryParse(section_no, out int i) && i < section_path.Length ? section_path[i] : null;
public bool has_errors => _has_errors.Value;
var rows = e.NewValue as IEnumerable<IHaveSectionPath>;
if (rows != null) {
var prv = CollectionViewSource.GetDefaultView(rows);
int n_groups = rows.Max(r => r.section_path.Length);
for (int i = 0; i < n_groups; i++) prv.GroupDescriptions.Add(new PropertyGroupDescription($"[{i}]"));
d.SetValue(ParameterRowsViewPropertyKey, prv);
} else d.SetValue(ParameterRowsViewPropertyKey, null);
}
public IEnumerable<IHaveSectionPath> ParameterRows { get => GetValue(ParameterRowsProperty) as IEnumerable<IHaveSectionPath>; set => SetValue(ParameterRowsProperty, value); }
#endregion
#region ParameterRowsViewSource (ReadOnly)
#region ParameterRowsView (ReadOnly)
private static readonly DependencyPropertyKey ParameterRowsViewPropertyKey = DependencyProperty.RegisterReadOnly("ParameterRowsView", typeof(ICollectionView), typeof(SyntheticEditor2),
new PropertyMetadata());
public static readonly DependencyProperty ParameterRowsViewProperty = ParameterRowsViewPropertyKey.DependencyProperty;
public ICollectionView ParameterRowsView { get => GetValue(ParameterRowsViewProperty) as ICollectionView; private set => SetValue(ParameterRowsViewPropertyKey, value); }
#endregion
#region ParameterCellTemplateSelector
public static readonly DependencyProperty ParameterCellTemplateSelectorProperty = DependencyProperty.Register("ParameterCellTemplateSelector", typeof(DataTemplateSelector), typeof(SyntheticEditor2),
#region ParameterCellTemplateConverter
public static readonly DependencyProperty ParameterCellTemplateConverterProperty = DependencyProperty.Register("ParameterCellTemplateConverter", typeof(IValueConverter), typeof(SyntheticEditor2),
new PropertyMetadata(SyncColumns));
public DataTemplateSelector ParameterCellTemplateSelector { get => GetValue(ParameterCellTemplateSelectorProperty) as DataTemplateSelector; set => SetValue(ParameterCellTemplateSelectorProperty, value); }
public IValueConverter ParameterCellTemplateConverter { get => GetValue(ParameterCellTemplateConverterProperty) as IValueConverter; set => SetValue(ParameterCellTemplateConverterProperty, value); }
#endregion
#region ParameterCellEditingTemplateSelector
public static readonly DependencyProperty ParameterCellEditingTemplateSelectorProperty = DependencyProperty.Register("ParameterCellEditingTemplateSelector", typeof(DataTemplateSelector), typeof(SyntheticEditor2),
#region ParameterCellEditingTemplateConverter
public static readonly DependencyProperty ParameterCellEditingTemplateConverterProperty = DependencyProperty.Register("ParameterCellEditingTemplateConverter", typeof(IValueConverter), typeof(SyntheticEditor2),
new PropertyMetadata(SyncColumns));
public DataTemplateSelector ParameterCellEditingTemplateSelector { get => GetValue(ParameterCellEditingTemplateSelectorProperty) as DataTemplateSelector; set => SetValue(ParameterCellEditingTemplateSelectorProperty, value); }
public IValueConverter ParameterCellEditingTemplateConverter { get => GetValue(ParameterCellEditingTemplateConverterProperty) as IValueConverter; set => SetValue(ParameterCellEditingTemplateConverterProperty, value); }
#endregion
#region RowHasError
@@ -134,32 +83,42 @@ namespace mbts.ui.spark
public static void SetRowHasErrors(DependencyObject d, bool value) { d.SetValue(RowHasErrorsProperty, value); }
#endregion
private static void GenerateParameterRows(DependencyObject d, DependencyPropertyChangedEventArgs e) {
var parameters = d.GetValue(ParametersProperty) as IReadOnlyCollection<IParameter>;
var legs = d.GetValue(LegTuplesProperty) as IReadOnlyCollection<LegSpreaderParamsTuple>;
d.SetValue(ParameterRowsPropertyKey, parameters.Select(p => new ParameterRow(p, legs)).ToList());
}
#region CellDataType
public static readonly DependencyProperty CellDataTypeProperty = DependencyProperty.RegisterAttached("CellDataType", typeof(Type), typeof(SyntheticEditor2), new PropertyMetadata(null));
public static Type GetCellDataType(DependencyObject d) { return d.GetValue(CellDataTypeProperty) as Type; }
public static void SetCellDataType(DependencyObject d, Type value) { d.SetValue(CellDataTypeProperty, value); }
#endregion
private static void SyncColumns(DependencyObject d, DependencyPropertyChangedEventArgs e) { ((SyntheticEditor2)d)._sync_columns(); }
public override void OnApplyTemplate() { _sync_columns(); }
private void _sync_columns() {
((DataGrid)GetTemplateChild("PART_DataGrid"))?.Columns.SetItems(LegTuples.Select(l => new DataGridColumnInternal(l.leg.Security) {
CellTemplateSelector = ParameterCellTemplateSelector,
CellEditingTemplateSelector = ParameterCellEditingTemplateSelector,
Width = 60
}));
((DataGrid)GetTemplateChild("PART_DataGrid"))?.Columns.SetItems(LegTuples.Select(l => new DataGridColumnInternal(l.leg.Security, ParameterCellTemplateConverter, ParameterCellEditingTemplateConverter) { Width = 60 }));
}
private class DataGridColumnInternal : DataGridDynamicTemplateColumn {
public DataGridColumnInternal(Security security) {
private class DataGridColumnInternal : DataGridDynamicColumn {
public DataGridColumnInternal(Security security, IValueConverter cell_template_converter, IValueConverter cell_editing_template_converter) {
Header = security.ToString(null);
SetValue(DataGridEx.CellKeyProperty, security);
_cell_template_converter = cell_template_converter;
_cell_editing_template_converter = cell_editing_template_converter;
}
private readonly IValueConverter _cell_template_converter, _cell_editing_template_converter;
protected override FrameworkElement generate_element_internal() { return _generate_element(_cell_template_converter); }
protected override FrameworkElement generate_editing_element_internal() { return _generate_element(_cell_editing_template_converter); }
private 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, });
return rv;
}
}
}
internal class RowHeaderGroupIndentConverter : IValueConverter
{
internal class RowHeaderGroupIndentConverter : IValueConverter {
public double Indent { get; set; }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) {
return new Thickness(((int)value + 1) * Indent, 0, 0, 0);
@@ -169,25 +128,24 @@ namespace mbts.ui.spark
}
}
internal class DataGridParameterCellTemplateSelector : DataTemplateSelector
{
[ValueConversion(typeof(Type), typeof(DataTemplate))]
internal class DataGridParameterCellTemplateConverter : IValueConverter {
public DataTemplate DoubleTemplate { get; set; }
public DataTemplate BooleanTemplate { get; set; }
public DataTemplate IntTemplate { get; set; }
public DataTemplate UIntTemplate { get; set; }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) {
Type t = (Type)value;
if (t == typeof(double)) return DoubleTemplate;
else if (t == typeof(bool)) return BooleanTemplate;
else if (t == typeof(int)) return IntTemplate;
else if (t == typeof(uint)) return UIntTemplate;
else return null;
}
public override DataTemplate SelectTemplate(object item, DependencyObject container) {
if (item != null) {
Type t = item.GetType();
if (t.IsGenericType) {
Type gt = t.GenericTypeArguments[0];
if (gt == typeof(bool)) return BooleanTemplate;
if (gt == typeof(double)) return DoubleTemplate;
if (gt == typeof(int)) return IntTemplate;
if (gt == typeof(uint)) return UIntTemplate;
}
}
return null;
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) {
throw new NotImplementedException();
}
}
}
@@ -19,7 +19,7 @@
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<usp:SyntheticEditor2 Margin="6" SyntheticName="{Binding name}" Parameters="{Binding parameters}" LegTuples="{Binding leg_tuples}" HorizontalAlignment="Stretch"/>
<usp:SyntheticEditor2 Margin="6" SyntheticName="{Binding name}" ParameterRows="{Binding rows}" LegTuples="{Binding leg_tuples}" HorizontalAlignment="Stretch"/>
<c:DialogSkirtOKCancel Grid.Row="1" OKCommand="{Binding commit}"/>
</Grid>
<u:WindowStyle.TitleContentTemplate>
@@ -0,0 +1,38 @@
using mbts.ui.shell;
using mbts.ui.spark;
using System;
namespace mbts.spark
{
internal partial class SyntheticEditorVM2
{
internal class Cell<T> : ViewModelBase, ICell {
public Cell(RowModelBase<T> model, LegSpreaderParamsTuple leg_tup) {
_model = model;
_leg_tup = leg_tup;
}
private readonly RowModelBase<T> _model;
private readonly LegSpreaderParamsTuple _leg_tup;
public T value {
get => _model.get_value(_leg_tup);
set {
_model.set_value(_leg_tup, value);
value_changed?.Invoke();
}
}
public virtual Type data_type { get; } = typeof(T);
public event Action value_changed;
}
internal class DynamicTypeCell : Cell<object>, IDisposable {
public DynamicTypeCell(DynamicTypeRowModelBase model, LegSpreaderParamsTuple leg_tup) : base(model, leg_tup) {
_data_type = new ObservablePropertySink<Type>(this, nameof(data_type), typeof(object));
_sub = model.data_type(leg_tup).ObserveOnDispatcher().Subscribe(_data_type);
}
private readonly ObservablePropertySink<Type> _data_type;
private readonly IDisposable _sub;
public override Type data_type => _data_type.Value;
public void Dispose() { _sub.Dispose(); }
}
}
}
@@ -0,0 +1,333 @@
using bts.api;
using bts.spark;
using mbts.ui.spark;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Reactive.Subjects;
namespace mbts.spark
{
internal partial class SyntheticEditorVM2
{
internal interface IRowModel : SyntheticEditor2.IHaveSectionPath {
string display_name { get; }
bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups);
ICell create_cell(LegSpreaderParamsTuple leg_tup);
}
internal interface ICell {
Type data_type { get; }
event Action value_changed;
}
private static class SectionNames {
public const string
LegDef = "Leg",
Quote = "Quote",
PreHedge = "PreHedge",
PostHedge = "PostHedge";
}
private static class SubsectionNames {
public const string
Mute = "Mute",
InsideMarketDistance = "Mute Inside Mkt Distance",
InsideMarketDistanceWithTravel = "Mute Inside Mkt Distance & Move",
Payless = "Pay Less",
Payup = "Pay up",
OrderType = "Order Type",
MarketForcedCross = "Price-Based Mkt Forced Cross",
TimeForcedCross = "Time-Based Forced Cross";
}
internal abstract class RowModelBase<T> : IRowModel {
protected RowModelBase() { }
public abstract string display_name { get; }
public virtual string[] section_path { get; } = new string[0];
public virtual IReadOnlyCollection<IRowModel> sub_items { get; }
public abstract T get_value(LegSpreaderParamsTuple leg_tup);
public abstract void set_value(LegSpreaderParamsTuple leg_tup, T value);
public virtual bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups) { return false; }
public virtual ICell create_cell(LegSpreaderParamsTuple leg_tup) { return new Cell<T>(this, leg_tup); }
}
internal abstract class DynamicTypeRowModelBase : RowModelBase<object> {
public abstract IObservable<Type> data_type(LegSpreaderParamsTuple leg_tup);
public override ICell create_cell(LegSpreaderParamsTuple leg_tup) { return new DynamicTypeCell(this, leg_tup); }
}
internal class SizeModel : RowModelBase<double> {
public override double get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg.Side == BuySell.Buy ? leg_tup.leg.Quantity : -leg_tup.leg.Quantity; }
public override void set_value(LegSpreaderParamsTuple leg_tup, double value) {
if (value >= 0) {
leg_tup.leg.Side = BuySell.Buy;
leg_tup.leg.Quantity = value;
} else {
leg_tup.leg.Side = BuySell.Sell;
leg_tup.leg.Quantity = -value;
}
}
public override string display_name { get; } = "Size";
public override string[] section_path { get; } = new[] { SectionNames.LegDef };
}
internal class PriceMultiplierModel : RowModelBase<double> {
public override double get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PriceMultiplier; }
public override void set_value(LegSpreaderParamsTuple leg_tup, double value) { leg_tup.leg_params.PriceMultiplier = value; }
public override string display_name { get; } = "Price Mult";
public override string[] section_path { get; } = new[] { SectionNames.LegDef };
}
internal class IsQuoteModel : RowModelBase<bool> {
public override bool get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.IsActiveQuoting; }
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) { leg_tup.leg_params.IsActiveQuoting = value; }
public override string display_name { get; } = "Is Active Quote";
public override string[] section_path { get; } = new[] { SectionNames.Quote };
public override bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups) { return !leg_tups.Any(lt => lt.leg_params.IsActiveQuoting); }
}
#region Quote
internal class LeanRatioModel : RowModelBase<double> {
public override string display_name { get; } = "Lean Ratio";
public override string[] section_path { get; } = new[] { SectionNames.Quote };
public override double get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.LeanQuantityRatio; }
public override void set_value(LegSpreaderParamsTuple leg_tup, double value) { leg_tup.leg_params.QuoteParams.LeanQuantityRatio = value; }
}
internal class MaxOrderMoveModel : RowModelBase<uint> {
public override string display_name { get; } = "Max Order Move";
public override string[] section_path { get; } = new[] { SectionNames.Quote };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteMaxOrderMove.MaxOrderMoveThreshold; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteMaxOrderMove.MaxOrderMoveThreshold = value; }
}
internal class QuoteMuteZoneInsideTicksModel : RowModelBase<uint> {
public override string display_name { get; } = "Inside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.Mute };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteMuteZone.InsideTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteMuteZone.InsideTicks = value; }
}
internal class QuoteMuteZoneOutsideTicksModel : RowModelBase<uint> {
public override string display_name { get; } = "Outside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.Mute };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteMuteZone.OutsideTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteMuteZone.OutsideTicks = value; }
}
internal class QuoteInsideMarketDistanceTicksModel : RowModelBase<uint> {
public override string display_name { get; } = "Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.InsideMarketDistance };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistance.TicksFromInside; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistance.TicksFromInside = value; }
}
internal class QuoteInsideMarketDistanceWithTravelTicksModel : RowModelBase<uint> {
public override string display_name { get; } = "Ticks";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.InsideMarketDistanceWithTravel };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.TicksFromInside; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.TicksFromInside = value; }
}
internal class QuoteInsideMarketDistanceWithTravelLimitModel : RowModelBase<uint> {
public override string display_name { get; } = "Min Move";
public override string[] section_path { get; } = new[] { SectionNames.Quote, SubsectionNames.InsideMarketDistanceWithTravel };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.Limit; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.QuoteParams.QuoteInsideMarketDistanceWithTravel.Limit = value; }
}
#endregion
#region PreHedge
internal class PayupRowGroup {
public PayupRowGroup() {
var is_ratio_model = new ThresholdIsRatioModel();
threshold_model = new ThresholdModel(is_ratio_model);
this.is_ratio_model = is_ratio_model;
}
public readonly IRowModel is_ratio_model, threshold_model, ticks_model = new TicksModel();
internal class TicksModel : RowModelBase<uint> {
public override string display_name { get; } = "Payup";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.Payup };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.PayupTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.PayupTicks = value; }
}
internal class ThresholdIsRatioModel : RowModelBase<bool> {
private uint _absolute;
private double _ratio;
private readonly ObservableDemuxer<Security, QuantityMeasure.QuantityOneofCase> _quantity_case_demuxer = new ObservableDemuxer<Security, QuantityMeasure.QuantityOneofCase>();
public override string display_name { get; } = "Is Ratio";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.Payup };
public override bool get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.QuantityCase == QuantityMeasure.QuantityOneofCase.Ratio; }
public override void set_value(LegSpreaderParamsTuple leg_tup, bool is_ratio) {
if (is_ratio) {
_absolute = leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Absolute;
leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Ratio = _ratio;
_quantity_case_demuxer.push_data(leg_tup.leg.Security, QuantityMeasure.QuantityOneofCase.Ratio);
} else {
_ratio = leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Ratio;
leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Absolute = _absolute;
_quantity_case_demuxer.push_data(leg_tup.leg.Security, QuantityMeasure.QuantityOneofCase.Absolute);
}
}
public IObservable<QuantityMeasure.QuantityOneofCase> quantity_case(LegSpreaderParamsTuple leg_tup) {
return _quantity_case_demuxer.subscribe(leg_tup.leg.Security).StartWith(leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.QuantityCase);
}
}
internal class ThresholdModel : DynamicTypeRowModelBase {
public ThresholdModel(ThresholdIsRatioModel is_ratio_model) {
_is_ratio_model = is_ratio_model;
}
private readonly ThresholdIsRatioModel _is_ratio_model;
public override string display_name { get; } = "Quantity";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.Payup };
public override object get_value(LegSpreaderParamsTuple leg_tup) {
switch (leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.QuantityCase) {
case QuantityMeasure.QuantityOneofCase.Absolute: return leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Absolute;
case QuantityMeasure.QuantityOneofCase.Ratio: return leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Ratio;
default: return null;
}
}
public override void set_value(LegSpreaderParamsTuple leg_tup, object value) {
switch (leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.QuantityCase) {
case QuantityMeasure.QuantityOneofCase.Absolute: leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Absolute = (uint)value; return;
case QuantityMeasure.QuantityOneofCase.Ratio: leg_tup.leg_params.PreHedgeParams.QuantityBasedPayupTicks.QuantityThreshold.Ratio = (double)value; return;
default: return;
}
}
public override IObservable<Type> data_type(LegSpreaderParamsTuple leg_tup) {
return _is_ratio_model.quantity_case(leg_tup).Select(qc => {
switch(qc) {
case QuantityMeasure.QuantityOneofCase.Absolute: return typeof(uint);
case QuantityMeasure.QuantityOneofCase.Ratio: return typeof(double);
default: return null;
}
});
}
}
}
internal class PaylessRowGroup {
public PaylessRowGroup() {
var is_ratio_model = new ThresholdIsRatioModel();
threshold_model = new ThresholdModel(is_ratio_model);
this.is_ratio_model = is_ratio_model;
}
public readonly IRowModel is_ratio_model, threshold_model, ticks_model = new TicksModel();
internal class TicksModel : RowModelBase<uint> {
public override string display_name { get; } = "Payless";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.Payless };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.PaylessTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.PaylessTicks = value; }
}
internal class ThresholdIsRatioModel : RowModelBase<bool> {
private uint _absolute;
private double _ratio;
private readonly ObservableDemuxer<Security, QuantityMeasure.QuantityOneofCase> _quantity_case_demuxer = new ObservableDemuxer<Security, QuantityMeasure.QuantityOneofCase>();
public override string display_name { get; } = "Is Ratio";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.Payless };
public override bool get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.QuantityCase == QuantityMeasure.QuantityOneofCase.Ratio; }
public override void set_value(LegSpreaderParamsTuple leg_tup, bool is_ratio) {
if (is_ratio) {
_absolute = leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Absolute;
leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Ratio = _ratio;
_quantity_case_demuxer.push_data(leg_tup.leg.Security, QuantityMeasure.QuantityOneofCase.Ratio);
} else {
_ratio = leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Ratio;
leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Absolute = _absolute;
_quantity_case_demuxer.push_data(leg_tup.leg.Security, QuantityMeasure.QuantityOneofCase.Absolute);
}
}
public IObservable<QuantityMeasure.QuantityOneofCase> quantity_case(LegSpreaderParamsTuple leg_tup) {
return _quantity_case_demuxer.subscribe(leg_tup.leg.Security).StartWith(leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.QuantityCase);
}
}
internal class ThresholdModel : DynamicTypeRowModelBase {
public ThresholdModel(ThresholdIsRatioModel is_ratio_model) {
_is_ratio_model = is_ratio_model;
}
private readonly ThresholdIsRatioModel _is_ratio_model;
public override string display_name { get; } = "Quantity";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.Payless };
public override object get_value(LegSpreaderParamsTuple leg_tup) {
switch (leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.QuantityCase) {
case QuantityMeasure.QuantityOneofCase.Absolute: return leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Absolute;
case QuantityMeasure.QuantityOneofCase.Ratio: return leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Ratio;
default: return null;
}
}
public override void set_value(LegSpreaderParamsTuple leg_tup, object value) {
switch (leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.QuantityCase) {
case QuantityMeasure.QuantityOneofCase.Absolute: leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Absolute = (uint)value; return;
case QuantityMeasure.QuantityOneofCase.Ratio: leg_tup.leg_params.PreHedgeParams.QuantityBasedPaylessTicks.QuantityThreshold.Ratio = (double)value; return;
default: return;
}
}
public override IObservable<Type> data_type(LegSpreaderParamsTuple leg_tup) {
return _is_ratio_model.quantity_case(leg_tup).Select(qc => {
switch (qc) {
case QuantityMeasure.QuantityOneofCase.Absolute: return typeof(uint);
case QuantityMeasure.QuantityOneofCase.Ratio: return typeof(double);
default: return null;
}
});
}
}
}
internal class MaxTicksInsideMarketModel : RowModelBase<uint> {
public override string display_name { get; } = "Max Inside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.MaxPriceFromInsideMarket.HedgeTickLimit; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PreHedgeParams.MaxPriceFromInsideMarket.HedgeTickLimit = value; }
}
internal class SendHedgeAsMarketOrderModel : RowModelBase<bool> {
public override string display_name { get; } = "Mkt Order Hedge";
public override string[] section_path { get; } = new[] { SectionNames.PreHedge, SubsectionNames.OrderType };
public override bool get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PreHedgeParams.SendHedgeAsMarketOrder.SendHedgeAsMarketOrder; }
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) { leg_tup.leg_params.PreHedgeParams.SendHedgeAsMarketOrder.SendHedgeAsMarketOrder = value; }
}
#endregion
#region PostHedge
internal class PostHedgePriceBasedCrossTicks : RowModelBase<uint> {
public override string display_name { get; } = "Max Outside Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.MarketForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.PriceBasedCross.TicksThreshold; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.PriceBasedCross.TicksThreshold = value; }
}
internal class PostHedgePriceBasedCrossMarketTicks : RowModelBase<uint> {
public override string display_name { get; } = "Opposite Mkt Cross Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.MarketForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.PriceBasedCross.MarketCrossTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.PriceBasedCross.MarketCrossTicks = value; }
}
internal class PostHedgeTimeBasedCrossTicks : RowModelBase<uint> {
public override string display_name { get; } = "Max Outside Time(ms)";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.TimeForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.TimeInMsThreshold; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.TimeInMsThreshold = value; }
}
internal class PostHedgeTimeBasedCrossMarketTicks : RowModelBase<uint> {
public override string display_name { get; } = "Opposite Mkt Cross Ticks";
public override string[] section_path { get; } = new[] { SectionNames.PostHedge, SubsectionNames.TimeForcedCross };
public override uint get_value(LegSpreaderParamsTuple leg_tup) { return leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.MarketCrossTicks; }
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) { leg_tup.leg_params.PostHedgeParams.TimeBasedForcedCross.MarketCrossTicks = value; }
}
#endregion
}
}
@@ -0,0 +1,36 @@
using bts.api;
using mbts.ui.controls;
using mbts.ui.spark;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
namespace mbts.spark
{
internal partial class SyntheticEditorVM2
{
internal class RowVM : DataGridExRow<Security>, SyntheticEditor2.IHaveSectionPath, IDisposable {
public RowVM(IRowModel model, IReadOnlyCollection<LegSpreaderParamsTuple> legs) {
display_name = model.display_name;
section_path = model.section_path;
_has_errors = backing(nameof(has_errors), false);
_cells = new ReadOnlyDictionary<Security, ICell>(legs.ToDictionary(l => l.leg.Security, model.create_cell));
foreach (var c in _cells.Values) {
c.value_changed += () => _has_errors.set(model.has_errors(legs));
}
}
private readonly IReadOnlyDictionary<Security, ICell> _cells;
private readonly Property<bool> _has_errors;
public string display_name { get; }
public string[] section_path { get; }
public int section_count => section_path.Length;
public override object get_cell(Security col_key) { return _cells[col_key]; }
public string this[string section_no] => int.TryParse(section_no, out int i) && i < section_path.Length ? section_path[i] : null;
public bool has_errors => _has_errors.Value;
public void Dispose() { foreach (var c in _cells.Values.OfType<IDisposable>()) c.Dispose(); }
}
}
}
@@ -11,8 +11,7 @@ namespace mbts.spark
/// <summary>
/// The view model designed to serve as the DataContext for the SyntheticEditor2 control
/// </summary>
internal partial class SyntheticEditorVM2
{
internal partial class SyntheticEditorVM2 {
/// <summary>
/// Initializes a new instance of SyntheticEditorVM2 class. The commit command will create a new Synthetic if synthetic's Id is 0, otherwise it will modify the existing synthetic's strategy.
/// </summary>
@@ -22,26 +21,32 @@ namespace mbts.spark
public SyntheticEditorVM2(IBus bus, Security synthetic, ExecutionStrategy strategy) {
_synthetic = synthetic;
leg_tuples = _synthetic.Synthetic.Legs.Select(l => new LegSpreaderParamsTuple(l, strategy.LegParamsMap[l.Security.Id])).ToList();
parameters = new SyntheticEditor2.IParameter[] {
new SizeRowModel(),
new PriceMultiplierRowModel(),
new IsQuoteRowModel(),
//new MaxOrderMoveRowModel(),
new QuoteMuteZoneInsideTicksRowModel(),
new QuoteMuteZoneOutsideTicksRowModel(),
new QuoteInsideMarketDistanceTicksRowModel(),
new QuoteInsideMarketDistanceWithTravelTicksRowModel(),
new QuoteInsideMarketDistanceWithTravelLimitRowModel(),
new PayupRowModel(),
new PaylessRowModel(),
new LeanRatioRowModel(),
new MaxTicksInsideMarketRowModel(),
new SendHedgeAsMarketOrderRowModel(),
var payless = new PaylessRowGroup();
var payup = new PayupRowGroup();
rows = new [] {
new SizeModel(),
new PriceMultiplierModel(),
new IsQuoteModel(),
//new MaxOrderMoveModel(),
new QuoteMuteZoneInsideTicksModel(),
new QuoteMuteZoneOutsideTicksModel(),
new QuoteInsideMarketDistanceTicksModel(),
new QuoteInsideMarketDistanceWithTravelTicksModel(),
new QuoteInsideMarketDistanceWithTravelLimitModel(),
new LeanRatioModel(),
new MaxTicksInsideMarketModel(),
payup.is_ratio_model,
payup.threshold_model,
payup.is_ratio_model,
payless.is_ratio_model,
payless.threshold_model,
payless.ticks_model,
new SendHedgeAsMarketOrderModel(),
new PostHedgePriceBasedCrossTicks(),
new PostHedgePriceBasedCrossMarketTicks(),
new PostHedgeTimeBasedCrossTicks(),
new PostHedgeTimeBasedCrossMarketTicks()
};
}.Select(m => new RowVM(m, leg_tuples)).ToList();
commit = new DelegateCommand(() => new SyntheticEditorModel(bus).save(_synthetic, strategy));
}
@@ -49,7 +54,7 @@ namespace mbts.spark
public string name { get => _synthetic.Synthetic.Name; set => _synthetic.Synthetic.Name = value; }
public IReadOnlyCollection<LegSpreaderParamsTuple> leg_tuples { get; }
public IReadOnlyCollection<SyntheticEditor2.IParameter> parameters { get; }
public IReadOnlyCollection<RowVM> rows { get; }
public ICommand commit { get; }
}
}